---
title: "Google Cloud Monitoring Phone Call Alerts via Webhook"
description: "Cloud Monitoring can email, text or push, but it can't call you. Send GCP alert policies to a calling webhook: setup, payload fields, filters, pitfalls."
date: 2026-11-15
author: Nooc
authorAvatarLink: /images/avatars/nooc.webp
authorLink: https://nooc.me
tags:
  - Google Cloud
  - Cloud Monitoring
  - GCP
  - phone call alerts
  - webhooks
  - on-call
---

# Google Cloud Monitoring Phone Call Alerts: From Alert Policy to a Ringing Phone

Google Cloud Monitoring has no way to call your phone. Its notification channels are email, SMS, the Google Cloud mobile app, Slack, Google Chat, PagerDuty, Pub/Sub and webhooks — and Google's own docs say SMS is not fully reliable and may not be available in your region. If you want an alert policy to ring like an incoming call, the shortest path is a webhook channel pointed at an Echobell calling channel, with two lines of template and one condition.

This guide covers the channel, the webhook, the fields in the payload that Cloud Monitoring actually sends, how to keep "open" incidents ringing and "closed" ones quiet, and the settings in the alert policy that decide how often your phone goes off.

## Why the built-in channels are not enough at 3 a.m.

- **Email** waits for you to look at it.
- **SMS** is, in Google's words, not a fully reliable channel type, and it might not be offered in your country. It is also silenced by Do Not Disturb like any other text.
- **The mobile app** sends an ordinary push. It shows on the lock screen; it does not keep ringing.
- **PagerDuty** can call you, but it is a full on-call platform with its own setup and contract.

A webhook channel, on the other hand, can reach anything with a public HTTPS endpoint, and Cloud Monitoring sends it a structured JSON document for every incident. That is all Echobell needs.

## What you need

- A Google Cloud project with at least one alerting policy (or an uptime check you want to alert on)
- Permission to edit notification channels (`roles/monitoring.notificationChannelEditor` or Monitoring Editor)
- Echobell installed ([App Store](https://apps.apple.com/app/apple-store/id6743597198?pt=128151925&ct=blog-google-cloud-monitoring-phone-call-alerts-en&mt=8) / [Google Play](https://play.google.com/store/apps/details?id=one.echobell.echobellandroid))
- Ten minutes

Nothing in your project has to accept inbound traffic. Cloud Monitoring makes the outbound request.

## Step 1 — Create a channel that rings

In Echobell, create a channel and set its notification type to **Calling**. A calling channel behaves like an incoming call rather than a push, so it takes over the screen and rings. Under iOS Focus Mode or Do Not Disturb it rings only if your Focus settings allow calls through.

Open the channel's **Advanced Settings** and turn on **Custom Template**. Cloud Monitoring wraps everything in an `incident` object, so the templates read nested fields:

```
Title: {{incident.state}}: {{incident.policy_name}}
Body: {{incident.summary}}
```

Set the **link template** so tapping the notification opens the incident in the Google Cloud console:

```
{{incident.url}}
```

Add a **condition** so only newly opened incidents ring:

```
incident.state == "open"
```

Copy the channel's webhook URL from the channel detail view:

```
https://hook.echobell.one/t/<channel-token>
```

## Step 2 — Add a webhook notification channel in Google Cloud

1. Open **Monitoring → Alerting** and click **Edit notification channels**
2. Under **Webhooks**, click **Add new**
3. **Endpoint URL**: your Echobell channel URL from Step 1
4. **Display name**: `Echobell (call)`
5. Leave **Use HTTP Basic Auth** off
6. Click **Test connection**, then **Save**

Leave Basic Auth off on purpose. Google's Basic Auth handshake expects the endpoint to answer the first request with `401` and a `WWW-Authenticate` header; Echobell authenticates by the secret token in the URL instead, so treat that URL like a password.

If you manage channels in Terraform, the same channel is:

```hcl
resource "google_monitoring_notification_channel" "echobell_call" {
  display_name = "Echobell (call)"
  type         = "webhook_tokenauth"

  labels = {
    url = "https://hook.echobell.one/t/<channel-token>"
  }
}
```

Keep the token out of version control — read it from a variable or Secret Manager rather than committing the URL.

## Step 3 — Attach the channel to the policies that deserve a call

Open an alerting policy, go to **Notifications and name**, and add `Echobell (call)` under **Notification channels**. A policy can notify several channels at once, so keep your existing email or Slack channel alongside it.

Be picky here. This is the real filter: a channel attached only to "production API is down" and "database is out of disk" rings rarely enough that you will still pick up. Leave "CPU above 70% for five minutes" on email.

Two settings on the same page shape what reaches your phone:

- **Notify on incident closure.** With it on, Cloud Monitoring also sends a notification when the incident closes. The `incident.state == "open"` condition from Step 1 keeps that one from ringing; Step 6 shows how to receive it quietly instead.
- **Incident autoclose duration.** If the metric stops reporting data, open incidents close after this period. Leave it at the default unless you have a reason not to.

## Step 4 — Know what the payload really looks like

Cloud Monitoring sends schema version 1.2 by default. Trimmed to the fields you are likely to use, an opened incident looks like this:

```json
{
  "version": "1.2",
  "incident": {
    "incident_id": "0.opqiw61fsv7p",
    "scoping_project_id": "my-project",
    "url": "https://console.cloud.google.com/monitoring/alerting/incidents/0.opqiw61fsv7p?project=my-project",
    "state": "open",
    "renotify": false,
    "started_at": 1794713564,
    "ended_at": null,
    "policy_name": "Prod API 5xx rate",
    "condition_name": "5xx ratio above 5%",
    "resource_display_name": "prod-api",
    "threshold_value": "0.05",
    "observed_value": "0.183",
    "severity": "Critical",
    "policy_user_labels": {
      "team": "payments"
    },
    "documentation": {
      "content": "Check the latest deploy first. Runbook: https://wiki.example.com/api-5xx",
      "mime_type": "text/markdown"
    },
    "summary": "5xx ratio for prod-api with metric labels {response_code_class=500} is above the threshold of 0.050 with a value of 0.183."
  }
}
```

Things worth knowing before you edit a template:

- **Everything is under `incident`.** `{{policy_name}}` renders empty; `{{incident.policy_name}}` does not.
- **`state` is `open` or `closed`.** That single field is what the condition and the title template rely on.
- **`summary` is generated text.** Google does not promise a stable format for it, so display it but do not match on it in a condition.
- **Fields can be missing.** Google notes that some fields are absent or null depending on the policy and the incident's state. A missing field renders as an empty string in Echobell, so a template keeps working; just do not build a condition on a field your policies do not set.
- **`documentation.content` is yours.** Whatever you type in the policy's **Documentation** box arrives here. A one-line instruction ("Check the latest deploy first") is more useful on a ringing phone than the generated summary.
- **Severity follows the policy.** It is whatever level you set on the policy. Send yourself a test incident and check the exact value before you filter on it.

A body that leads with your own words and falls back on the summary:

```
{{incident.documentation.content}}
{{incident.summary}}
```

## Step 5 — Decide what rings, and how often

Most of the filtering already happened when you chose which policies get the channel. Echobell's channel condition handles the rest.

| Goal | Condition |
| --- | --- |
| Ring only when an incident opens | `incident.state == "open"` |
| Ring once, not on every reminder | `incident.state == "open" && !incident.renotify` |
| Ring only for one team's policies | `incident.state == "open" && incident.policy_user_labels.team == "payments"` |
| Ring only overnight (00:00–07:00 UTC) | `incident.state == "open" && hour < 7` |

**Reminders.** A policy can resend notifications while an incident stays open: in the API it is `alertStrategy.notificationChannelStrategy[].renotifyInterval`, anywhere from 30 minutes to 24 hours. Those repeats arrive with `renotify: true`. Whether they should ring is a choice: ringing again is a crude but effective escalation for an incident nobody fixed, and skipping them keeps a long outage from ringing all night. The second row of the table does the skipping.

**User labels.** Policy user labels, such as `team: payments`, travel in `policy_user_labels`. A condition on them lets a channel attached to many policies ring for some and stay quiet for the rest. They filter; they do not route: each webhook URL always triggers the same Echobell channel, so a label cannot send an incident to someone else's channel.

Echobell's time variables are in UTC, so convert from your own timezone first. The [conditions reference](/en/docs/conditions) lists every variable.

## Step 6 — Give closures a quieter door

With **Notify on incident closure** on, a closed incident is good news worth seeing, not worth a ring. Create a second Echobell channel of type **Time Sensitive** (or normal) with the same templates and no condition, add it to Google Cloud as a second webhook channel, and attach both to the policy. The title template already reads "closed: Prod API 5xx rate".

| Echobell channel | Condition | Channel type | Behaviour |
| --- | --- | --- | --- |
| `gcp-call` | `incident.state == "open"` | Calling | Rings like an incoming call |
| `gcp-log` | none | Time Sensitive or Normal | Every open, reminder and close, without ringing |

## Test it before you trust it

**Test the Echobell side first.** Post a payload shaped like Cloud Monitoring's:

```bash
curl -X POST https://hook.echobell.one/t/<channel-token> \
  -H 'Content-Type: application/json' \
  -d '{"version":"1.2","incident":{"state":"open","renotify":false,"policy_name":"Manual test","summary":"Testing the Echobell path","url":"https://console.cloud.google.com/monitoring/alerting"}}'
```

**Then test the Google side.** The **Test connection** button sends a sample payload whose fields are not a real incident, so it may not pass your condition. For an end-to-end test, create a throwaway policy with a threshold you are already above — for example, VM CPU utilization above 1% — attach `Echobell (call)`, wait for it to fire, then delete the policy.

If the `curl` rings and the real policy does not, the problem is on the Google side — the channel is not attached, the condition has not been met for its duration yet, or the endpoint URL was copied wrong — not in the Echobell channel.

## Log-based alerts and uptime checks

- **Uptime checks** do not notify anyone on their own; they feed an alerting policy. Create the policy from the uptime check and attach the same webhook channel.
- **Log-based alerting policies** notify only when an incident opens — Google does not send a closure notification for them — and they require a notification rate limit, which caps how often a noisy log line can ring you. The `incident.state == "open"` condition still works; the closure channel simply never hears from these policies.

## Limits that matter during an incident

- **1 MiB body.** Echobell rejects trigger bodies over 1 MiB with HTTP 413. A Cloud Monitoring incident is a few kilobytes.
- **120 requests per minute per token.** Past that the trigger answers `429` with `RATE_LIMIT_EXCEEDED` and a `Retry-After`. One policy rarely comes close, but dozens of policies firing at once during a regional outage can — another reason to keep the calling channel on a short list.
- **1500 bytes of notification body.** Longer renders are truncated. Keep the policy documentation short, or put the runbook link in it rather than the runbook.

## What this setup does not give you

- **No acknowledgement.** Answering the call does not acknowledge or close the incident in Google Cloud.
- **No escalation or rotation.** Everyone subscribed to the channel is called; nobody is called next.
- **No deduplication beyond the incident.** A condition that flaps opens a new incident each time, and each one rings. Fix it on the policy with a longer duration window.

If those are dealbreakers, you want a full on-call platform. If what you need is "ring me when the production policy fires", this is two screens in the console.

## Troubleshooting

**The incident opened but nothing arrived.** Open the incident in **Monitoring → Alerting** and check that the policy lists the webhook channel. Make sure the endpoint URL is the full Echobell URL, token included.

**The notification arrived but did not ring.** The channel type is not **Calling**, or your phone's Focus settings do not allow calls through. Check the channel and your Focus configuration.

**The notification is blank.** The template is reading top-level fields. Prefix them with `incident.` — `{{incident.policy_name}}`, not `{{policy_name}}`.

**It rings again every half hour.** The policy has a renotify interval. Remove it, or add `!incident.renotify` to the condition.

**It rings when the incident closes.** The condition is missing `incident.state == "open"`, or is on the wrong channel.

## Frequently asked questions

### Can Google Cloud Monitoring call a phone number natively?

No. The notification channels are email, SMS, the Google Cloud mobile app, Slack, Google Chat, PagerDuty, Pub/Sub and webhooks. A voice call needs an external service: an on-call platform, or a calling webhook like Echobell.

### Do I need Pub/Sub or a Cloud Function?

No. Cloud Monitoring posts the incident to the webhook URL itself. Pub/Sub is Google's recommendation for endpoints that are not public; Echobell's endpoint is public, so the webhook channel is enough.

### Will a Cloud Monitoring alert break through Do Not Disturb?

Only if it arrives as a call-style alert. A calling-type Echobell channel behaves like an incoming call, which iOS Focus Mode and Do Not Disturb let through when your Focus settings allow calls. An SMS or an ordinary push does not. Turn on **Retry Failed Call** as well: with Allow Repeated Calls on in your Focus settings, a second call within three minutes can ring.

### Should I use the Basic Auth option on the webhook?

No. Echobell authenticates by the token in the URL. Google's Basic Auth flow expects a `401` challenge first, which Echobell does not send.

### Can I call different people for different policies?

Yes. Create one Echobell channel per audience, add each channel's URL to Google Cloud as its own webhook channel, and attach each one to the policies that audience owns. One webhook URL always triggers the same Echobell channel, so a `policy_user_labels` condition can mute policies on that channel but cannot hand them to another one. There is no acknowledgement, so everyone subscribed with "calling" is called.

### What about several projects?

A notification channel belongs to one project. Create the webhook channel in each project — the same Echobell URL works in all of them — or alert from a scoping project that monitors the others.

## Wrap-up

The path is four parts: a calling channel with an `incident.state == "open"` condition, a webhook notification channel pointed at it, a short list of policies that deserve a call, and a real test before you rely on it. The rest is about keeping that list short enough that a ring still means something a month from now.

[Download Echobell for iPhone](https://apps.apple.com/app/apple-store/id6743597198?pt=128151925&ct=blog-google-cloud-monitoring-phone-call-alerts-en&mt=8) or [get it on Google Play](https://play.google.com/store/apps/details?id=one.echobell.echobellandroid), then point your most important alerting policy at it.

## Related

- [Channel conditions reference](/en/docs/conditions)
- [Template reference](/en/docs/template)
- [Webhook integration guide](/en/docs/webhook)
- [CloudWatch alarm phone call alerts](/en/blog/cloudwatch-alarm-phone-call-alerts)
- [Alertmanager phone call alerts](/en/blog/alertmanager-phone-call-alerts)
- [A developer's guide to fixing alert fatigue](/en/blog/fix-alert-fatigue-developer-guide)
- [Bypassing iOS Focus Mode for critical alerts](/en/blog/how-to-bypass-ios-focus-mode-for-critical-alerts)
