The MCP tool directory.

Mint a new signing secret and return it exactly once; it cannot be retrieved afterward. Both the old and new secrets sign every delivery for 24 hours, after which the old one stops signing. An endpoint holds at most 5 valid secrets, so rotating repeatedly inside that window fails.

Send a signed synthetic event and get the outcome synchronously: whether the endpoint accepted, the HTTP status it returned, and the round-trip latency. An unreachable endpoint comes back as a failed status in the body rather than a request error. The receiver has 10 seconds, the body is a minimal stub carrying only the event type, and a test reaches even a paused endpoint without being recorded in the delivery attempts.

Use this when you need to convert a live web page to a printable PDF document. Renders in a real Chromium browser and returns binary PDF. Returns: 1. Binary PDF file 2. Configurable paper format (A4,

The latest written digest: headline, what moved, and recommended actions. Reads the stored digest — does not call an LLM. If none exists, says so and points at get_visibility_snapshot. Pass brandId, or brandName to resolve via find.

Read one connected WhatsApp Business Account by its `id` (`waa_` prefix) or the ID WhatsApp reports in `waba`, with the state WhatsApp reports for the account.

List the WhatsApp Business Accounts the workspace has connected, as a cursor page, with the state WhatsApp reports for each. The `waba` a returned account carries is the same value that ties a number to its account, and the one `whatsapp_numbers_list`'s `waba` filter takes.

Get one WhatsApp message by id: current delivery status, sent/delivered/read timestamps, the one content it was built from (a template, or free-form text, image, video, audio, sticker, document or location), and failure detail if it failed. For the per-event timeline use whatsapp_list_events.

List WhatsApp messages, newest first, as a cursor page ({data, next_cursor, …}). Each message carries the one content it was built from: a template, or free-form text, image, video, audio, sticker, document or location. Pass next_cursor back as starting_after to fetch the next page. Filter by direction, status, recipient (to), sender (from), business-scoped user ID (bsuid), template category, or tag. to and from each accept a phone number or a business-scoped user ID; pair either with direction to search a single side of the message. Use whatsapp_get for one message's current state.

Get one WhatsApp message's delivery timeline, oldest first: whatsapp.accepted, whatsapp.sent, whatsapp.delivered, whatsapp.read, and whatsapp.failed events, with failure detail on failed events. Not paginated; an unknown message ID returns `404`. Use `whatsapp_get` for the condensed current status.

Download the media on a received WhatsApp message. The media ID is the message content object's `id`, from `whatsapp_get`. Up to 5 MiB, media returns inline as a blob; larger media returns a pre-authorized URL valid 15 minutes and needing no Authorization header. Media expires 30 days after the message arrives, when this returns 410; outbound messages carry no stored media.

Connect a number the workspace already holds to WhatsApp. Take the number's id from `numbers_list`, where a connectable number is a dedicated one (`nda_` prefix) that can receive text messages; WhatsApp proves ownership for you, so no verification code is asked for. The number comes back `preparing` and takes a couple of minutes. Read it back with `whatsapp_numbers_get` until it reports `awaiting_signup`, at which point it carries `finish_setup_url` (a browser flow behind an OAuth screen that a person must complete, and that no operation here can substitute for). `failed` means it could not be prepared and `error` says why.

Disconnect a WhatsApp number from the workspace so it can no longer send.

Read a WhatsApp number and the state WhatsApp reports for it. `next` says what to do about that state, including the browser step that finishes a connection while `status` is `awaiting_signup`.

List the WhatsApp numbers the workspace can send from as a cursor page, with each number's WhatsApp state, quality rating, messaging limit and throughput.

Check whether WhatsApp will accept a phone number before buying it: take a number from `numbers_available_list`, check it here, and order it with `numbers_orders_create` only if this check answers `available`. It is a write rather than a lookup, so check the number you intend to buy rather than sweeping a list of candidates, and reuse an `Idempotency-Key` to get the stored answer back instead of asking WhatsApp again.

Read the business profile WhatsApp shows to people a connected number messages.

Change the business profile WhatsApp shows to people a connected number messages. `username_transfer_action: force_transfer` takes the username off another of the workspace's numbers and the response does not say which, so confirm with a person before sending it.

Change your workspace's own label for a connected WhatsApp number.

Send one WhatsApp message to a single recipient, carrying exactly one kind of content: a template, or free-form text, image, video, audio, sticker, document or location. A template is the only content deliverable outside an open 24-hour customer service window. For a Bird-managed template Bird selects the sender number, so omit from; every other send requires from and it must be a number your workspace owns. `whatsapp_templates_list` carries the names a template send accepts, with the languages each template can currently resolve. The response is the accepted message with its id; delivery is asynchronous, so use whatsapp_get to check delivery status.

Failed outbound WhatsApp messages grouped by the normalized failure reason, the same value a failed message reports in `last_error.code`, ranked by volume. This is the read that answers "why are sends failing"; `whatsapp_stats_summary` gives the failure rate, this gives its composition. A send declined before handoff (insufficient balance, missing price, suppressed recipient) counts as rejected rather than failed and is absent here; read `delivery.rejected` on `whatsapp_stats_summary` for it. Rows are the whole workspace's: the breakdown takes no dimension filter. Cap the rows with `limit` (default 50, max 200).

Outbound WhatsApp counts grouped by the business number that sent them, ranked by accepted volume, each row marked as a number your workspace connected or one Bird manages on your behalf. Use it to find the sender behind a delivery problem, then read that number's own state from `whatsapp_numbers_list` filtered by `phone_number`: a row carries the number itself, not its `wan_` id. Rows are the whole workspace's: the breakdown takes no dimension filter.

Outbound WhatsApp counts grouped by the tags a send attached, ranked by accepted volume. A row's tag is `name:value`, so one tag name spreads over as many rows as it has values. Rows are the whole workspace's: the breakdown takes no dimension filter; to see one tag over time, filter `whatsapp_stats_daily` by `tag` instead. Cap the rows with `limit` (default 50, max 200).

Outbound WhatsApp counts grouped by template slug, ranked by accepted volume. Rows sum to less than the period's accepted total: a free-form send resolves no template, and some volume cannot be attributed to one at all, so take the denominator from `whatsapp_stats_summary`. Rows are the whole workspace's: the breakdown takes no dimension filter; to see one template over time, filter `whatsapp_stats_daily` by `template` instead. Cap the rows with `limit` (default 50, max 200).

Outbound WhatsApp counts grouped by Meta's template category (`authentication`, `utility` and `marketing` today, and the vocabulary is open), ranked by accepted volume. Category is what WhatsApp prices a message on, so this is the breakdown that explains a spend change. A free-form send carries no category, so rows sum to less than the period's accepted total; take the denominator from `whatsapp_stats_summary`. Rows are the whole workspace's: the breakdown takes no dimension filter. Cap the rows with `limit` (default 50, max 200).

Outbound WhatsApp lifecycle counts, one row per calendar day of the window, gap-filled so a silent day is a zero row rather than a missing one. Every event a message produces counts against the day that message was accepted, so a row is a funnel over that day's sends and recent rows under-report while callbacks arrive. Each row carries its own latency percentiles, but delivery, failure and read rates are whole-window figures: read those from `whatsapp_stats_summary`. Accepts the same single-dimension restriction: `template`, `category`, `phone_number` or `tag`. Days are calendar days in `timezone`, or UTC when it is omitted. Max window 365 days; `from` and `to` default to the trailing 30 days.

Outbound WhatsApp lifecycle counts, one row per hour, gap-filled. Every event a message produces counts against the hour that message was accepted, so a row is a funnel over that hour's sends and recent rows under-report while callbacks arrive. Each row carries its own latency percentiles, but delivery, failure and read rates are whole-window figures: read those from `whatsapp_stats_summary`. Use it where the daily grain hides the shape; a window spans at most 720 hours (30 days), and for anything longer use `whatsapp_stats_daily`. Accepts the same single-dimension restriction: `template`, `category`, `phone_number` or `tag`. `from` and `to` are optional RFC 3339 instants, defaulting to the trailing 168 hours.

Received WhatsApp message counts grouped by the business number that received them, ranked by volume. Use it to see which of your numbers customers actually write to. Cap the rows with `limit` (default 50, max 200).

Received WhatsApp message counts, one row per calendar day of the window, gap-filled so a silent day is a zero row. Days are calendar days in `timezone`, or UTC when it is omitted. Max window 365 days; `from` and `to` default to the trailing 30 days.

Received WhatsApp message counts, one row per hour, gap-filled. A window spans at most 720 hours (30 days); for anything longer use `whatsapp_stats_inbound_daily`. `from` and `to` are optional RFC 3339 instants.

Aggregate count of the WhatsApp messages your workspace received in one window, with the delta against the window immediately before when `compare` is set to `previous_period`. Inbound is counted separately from outbound: this answers "how much are customers writing to us", where `whatsapp_stats_summary` answers "how much are we sending".