ruby-whatsapp 0.4.0 → 0.6.1

data/docs/README.md

@@ -0,0 +1,76 @@
+# ruby-whatsapp documentation
+
+Full reference for [ruby-whatsapp](https://github.com/saleszera/ruby-whatsapp). The
+[project README](../README.md) is the short version.
+
+## Start here
+
+| Page | Covers |
+| --- | --- |
+| [configuration.md](configuration.md) | Credentials, the client, connection reuse, instrumentation, which ID addresses what |
+| [errors.md](errors.md) | The full exception hierarchy, validation vs API failures, retry strategy |
+
+## Outbound — talking to customers
+
+| Page | Covers |
+| --- | --- |
+| [messages/](messages/README.md) | Sending every message kind, the shared envelope, responses |
+| [media/](media/README.md) | Upload, download, delete, and the token-safety allowlist |
+| [message_templates/](message_templates/README.md) | Creating and managing the templates you send |
+| [schedule/](schedule/README.md) | Scheduling an approved template to go out to an audience later |
+
+### Message kinds
+
+[text](messages/text.md) ·
+[image](messages/image.md) ·
+[video](messages/video.md) ·
+[audio](messages/audio.md) ·
+[document](messages/document.md) ·
+[sticker](messages/sticker.md) ·
+[reaction](messages/reaction.md) ·
+[location](messages/location.md) ·
+[contacts](messages/contacts.md) ·
+[address](messages/address.md) ·
+[location request](messages/location_request.md) ·
+[template](messages/template.md) ·
+[interactive](messages/interactive.md) ·
+[mark as read](messages/mark_message_as_read.md)
+
+### Template kinds
+
+[standard](message_templates/standard.md) ·
+[authentication](message_templates/authentication.md) ·
+[carousel](message_templates/carousel.md) ·
+[limited-time offer](message_templates/limited_time_offer.md) ·
+[library](message_templates/library.md) ·
+[components reference](message_templates/components.md) ·
+[responses](message_templates/responses.md)
+
+## Inbound — hearing back
+
+| Page | Covers |
+| --- | --- |
+| [webhooks/](webhooks/README.md) | Install, verification, signature, dispatch, all 21 notification fields |
+| [webhooks/messages.md](webhooks/messages.md) | Inbound messages and delivery statuses — the one you'll actually use |
+
+## Account administration
+
+| Page | Covers |
+| --- | --- |
+| [subscribed_app/](subscribed_app/README.md) | Turning webhook delivery on and off for a WABA |
+| [business_phone_number/](business_phone_number/README.md) | Onboarding a phone number: request code → verify → register |
+| [business_phone_number/account.md](business_phone_number/account.md) | Reading and updating the business account itself |
+| [business_phone_number/profile.md](business_phone_number/profile.md) | Reading and updating the business profile a user sees |
+| [business_phone_number/username.md](business_phone_number/username.md) | Claiming and managing the searchable business username |
+| [business_phone_number/contact_book.md](business_phone_number/contact_book.md) | Removing a stored user contact from Meta's contact book |
+
+## Reading order
+
+New to the Cloud API? Follow the setup path in order:
+
+1. [configuration.md](configuration.md) — get credentials in place
+2. [business_phone_number/](business_phone_number/README.md) — register the number
+3. [messages/text.md](messages/text.md) — send something
+4. [subscribed_app/](subscribed_app/README.md) — turn on webhook delivery
+5. [webhooks/](webhooks/README.md) — receive the reply
+6. [message_templates/](message_templates/README.md) — message outside the 24-hour window

data/docs/business_phone_number/README.md

@@ -0,0 +1,243 @@
+# Registering Business Phone Numbers
+
+A business phone number is unusable with Cloud API until it is **registered**.
+Registration is the prerequisite that makes sending, media, and templates work for that
+number at all — not an optional extra.
+
+`Whatsapp::BusinessPhoneNumber` wraps all four endpoints in that path:
+
+```
+RequestCode  ->  VerifyCode  ->  Register            (onboarding)
+(send OTP)       (confirm it)    (activate on Cloud API)
+
+Deregister                                            (the reverse switch)
+```
+
+Addresses your **phone number** (`phone_id`, not `waba_id`), like
+[messages](../messages/README.md) and [media](../media/README.md), and needs both the
+`whatsapp_business_messaging` and `whatsapp_business_management` permissions.
+
+> **Looking for the account itself?** [`Account::Get` / `Account::Update`](account.md)
+> read and update the WhatsApp Business Account a number belongs to — its name,
+> timezone, review and verification status. Those are the one `waba_id`-scoped corner
+> of this module.
+
+> **Looking for the profile a user sees?** [`Profile::Get` / `Profile::Update`](profile.md)
+> read and write the about line, description, address, email, websites, industry vertical,
+> and picture. Those address your phone number (`phone_id`), just like the four actions
+> below.
+
+> **Looking for the username?** [`Username::Get` / `Claim` / `Delete` / `Suggest`](username.md)
+> read and set the searchable `@name` a WhatsApp user can find the number by, and
+> [`ContactBook::Delete`](contact_book.md) forgets a stored user contact. Both address
+> `phone_id`, like the four actions below.
+
+> **Unrelated to [`SubscribedApp`](../subscribed_app/README.md).** That turns *webhook
+> delivery* on and off for a whole WhatsApp Business Account. This is per phone number
+> and has nothing to do with notifications.
+
+## The whole flow
+
+```ruby
+Whatsapp.configure do |config|
+  config.api_key  = ENV.fetch("WHATSAPP_API_KEY")
+  config.phone_id = ENV.fetch("WHATSAPP_PHONE_ID")
+end
+
+Whatsapp::BusinessPhoneNumber::RequestCode.call(code_method: "SMS", language: "en_US")
+Whatsapp::BusinessPhoneNumber::VerifyCode.call(code: "123456")
+Whatsapp::BusinessPhoneNumber::Register.call(pin: "212834")
+Whatsapp::BusinessPhoneNumber::Deregister.call
+```
+
+| Method | Request | Returns |
+| --- | --- | --- |
+| `RequestCode.call(code_method:, language:)` | `POST /{phone_id}/request_code` | `Response` |
+| `VerifyCode.call(code:)` | `POST /{phone_id}/verify_code` | `Response` (may carry `id`) |
+| `Register.call(pin:, data_localization_region:)` | `POST /{phone_id}/register` | `Response` |
+| `Deregister.call` | `POST /{phone_id}/deregister` | `Response` |
+| [`Account::Get.call(fields:)`](account.md) | `GET /{waba_id}` | `Account::Details` |
+| [`Account::Update.call(name:, timezone_id:)`](account.md) | `POST /{waba_id}` | `Response` |
+| [`Profile::Get.call(fields:)`](profile.md) | `GET /{phone_id}/whatsapp_business_profile` | `Profile::Details` |
+| [`Profile::Update.call(**fields)`](profile.md) | `POST /{phone_id}/whatsapp_business_profile` | `Response` |
+| [`Username::Get.call`](username.md) | `GET /{phone_id}/username` | `Username::Details` |
+| [`Username::Claim.call(username:, transfer_action:)`](username.md) | `POST /{phone_id}/username` | `Username::Details` |
+| [`Username::Delete.call`](username.md) | `DELETE /{phone_id}/username` | `Response` |
+| [`Username::Suggest.call`](username.md) | `GET /{phone_id}/username_suggestions` | `Username::Suggestions` |
+| [`ContactBook::Delete.call(bsuid:)`](contact_book.md) | `DELETE /{phone_id}/contact_book` | `ContactBook::Deletion` |
+
+Every action accepts an optional `client:` and raises
+`Whatsapp::BusinessPhoneNumber::Error` if `phone_id` is missing or the API rejects the
+request.
+
+## Requesting a verification code
+
+Sends a one-time code to the number, by SMS or automated voice call.
+
+```ruby
+Whatsapp::BusinessPhoneNumber::RequestCode.call(code_method: "SMS", language: "en_US").success
+# => true
+```
+
+| Field | Required | Rules |
+| --- | --- | --- |
+| `code_method` | yes | `"SMS"` or `"VOICE"` — either casing accepted, emitted uppercase |
+| `language` | yes | The locale for the message, e.g. `"en_US"`. Presence only |
+
+> `language` is deliberately **not** checked against `Utils::LanguageCodes`. That list
+> is the set of locales Meta *approves templates* in; this field is closer to a
+> delivery preference, and Meta documents it as a plain string with no enum.
+
+```ruby
+Whatsapp::BusinessPhoneNumber::RequestCode.call(code_method: "CARRIER_PIGEON", language: "en_US")
+# => ActiveModel::ValidationError: Code method is not included in the list
+```
+
+Both fields are always sent — neither is compacted away:
+
+```ruby
+Whatsapp::BusinessPhoneNumber::RequestCode.new(code_method: "sms", language: "en_US").serialize
+# => { code_method: "SMS", language: "en_US" }
+```
+
+## Verifying the code
+
+```ruby
+result = Whatsapp::BusinessPhoneNumber::VerifyCode.call(code: "123456")
+
+result.success   # => true
+result.id        # => "106540352242922"  — the phone number ID, when Meta returns one
+```
+
+`code` is checked for presence only — Meta documents no format, so a wrong-but-present
+code is rejected server-side.
+
+The OTP is redacted from `#inspect`:
+
+```ruby
+Whatsapp::BusinessPhoneNumber::VerifyCode.new(code: "123456").inspect
+# => "#<Whatsapp::BusinessPhoneNumber::VerifyCode code=[REDACTED]>"
+```
+
+## Registering
+
+The step that actually activates the number on Cloud API.
+
+```ruby
+Whatsapp::BusinessPhoneNumber::Register.call(pin: "212834").success
+# => true
+```
+
+| Field | Required | Rules |
+| --- | --- | --- |
+| `pin` | yes | Exactly **6 digits** — the existing two-step verification PIN, or the one to set |
+| `data_localization_region` | no | One of 14 region codes |
+
+```ruby
+Whatsapp::BusinessPhoneNumber::Register.call(pin: "1234")
+# => ActiveModel::ValidationError: Pin must be exactly 6 digits
+```
+
+### Data localization
+
+Passing a region enables local storage — message data at rest stays in that region:
+
+```ruby
+Whatsapp::BusinessPhoneNumber::Register.call(pin: "212834", data_localization_region: "CH")
+```
+
+| Region | Codes |
+| --- | --- |
+| APAC | `AU` `ID` `IN` `JP` `SG` `KR` |
+| Europe | `DE` `CH` `GB` |
+| LATAM | `BR` |
+| MEA | `BH` `ZA` `AE` |
+| NORAM | `CA` |
+
+Omitted when not given:
+
+```ruby
+Whatsapp::BusinessPhoneNumber::Register.new(pin: "212834").serialize
+# => { messaging_product: "whatsapp", pin: "212834" }
+
+Whatsapp::BusinessPhoneNumber::Register.new(pin: "212834", data_localization_region: "ch").serialize
+# => { messaging_product: "whatsapp", pin: "212834", data_localization_region: "CH" }
+```
+
+The PIN is redacted from `#inspect`, and no validation error message ever echoes it:
+
+```ruby
+Whatsapp::BusinessPhoneNumber::Register.new(pin: "212834", data_localization_region: "CH").inspect
+# => "#<Whatsapp::BusinessPhoneNumber::Register pin=[REDACTED] data_localization_region=\"CH\">"
+```
+
+## Deregistering
+
+```ruby
+Whatsapp::BusinessPhoneNumber::Deregister.call.success   # => true
+```
+
+Deregistering makes the number unusable with Cloud API and disables local storage. It
+does **not** delete the number or its message history. A number in use with both Cloud
+API and the WhatsApp Business app cannot be deregistered.
+
+`Deregister` takes no arguments and has nothing to validate — its payload is `{}`.
+
+## Targeting a different number
+
+Inject a client rather than mutating global configuration:
+
+```ruby
+Whatsapp::BusinessPhoneNumber::Register.call(
+  pin: "212834",
+  client: Whatsapp::Client.new(phone_id: "OTHER_PHONE_ID")
+)
+```
+
+## Rate limits
+
+> **`Register` / `Deregister`:** 10 requests per business number in a **72-hour moving
+> window**. Exceeding it returns error `133016` and blocks the operation for the next
+> 72 hours.
+>
+> **`RequestCode` / `VerifyCode`:** "standard Graph API rate limits", plus possible
+> additional throttling — Meta publishes no number.
+
+This is server-side state the gem cannot observe, so there is no client-side tracking.
+It is also why every action validates locally first: a rejected attempt still counts
+against the limit.
+
+## Errors
+
+```ruby
+Whatsapp::BusinessPhoneNumber::Register.call(pin: "212834")
+# => Whatsapp::BusinessPhoneNumber::Error: phone_id is required for the register edge;
+#    set it via Whatsapp.configure or Client.new(phone_id:)
+
+# non-2xx response
+# => Whatsapp::BusinessPhoneNumber::Error: Failed to register business phone number:
+#    400 Bad Request - {"error":{"message":"..."}}
+```
+
+Local validation failures raise `ActiveModel::ValidationError` before any request. See
+[../errors.md](../errors.md).
+
+## Not wrapped
+
+- **Client-side rate-limit tracking** — server-side state the gem cannot observe.
+- **Two-step verification PIN management.** `Register` *consumes* an existing PIN;
+  setting or changing one is a different endpoint.
+
+---
+
+**See also:** [Reading and updating the business account](account.md) ·
+[Reading and updating the business profile](profile.md) ·
+[Business usernames](username.md) · [Contact book](contact_book.md)
+
+---
+
+**Meta docs:**
+[registration](https://developers.facebook.com/documentation/business-messaging/whatsapp/business-phone-numbers/registration)
+· [request code](https://developers.facebook.com/documentation/business-messaging/whatsapp/reference/whatsapp-business-phone-number/phone-number-verification-request-code-api)
+· [verify code](https://developers.facebook.com/documentation/business-messaging/whatsapp/reference/whatsapp-business-phone-number/verify-code-api)
+· [deregister](https://developers.facebook.com/documentation/business-messaging/whatsapp/reference/whatsapp-business-phone-number/phone-number-deregister-api)

data/docs/business_phone_number/account.md

@@ -0,0 +1,170 @@
+# Reading and Updating the Business Account
+
+Every business phone number belongs to a **WhatsApp Business Account** (WABA). The rest
+of this module drives a *number's* onboarding; `Whatsapp::BusinessPhoneNumber::Account`
+reads and writes the *account* that number sits inside — whether Meta has approved it,
+whether the business behind it is verified, who owns it, and what it is called.
+
+> **The one `waba_id` corner of this module.**
+> [`RequestCode`/`VerifyCode`/`Register`/`Deregister`](README.md) address your phone
+> number (`phone_id`). `Account` addresses the account (`waba_id`), like
+> [template management](../message_templates/README.md) and
+> [subscribed apps](../subscribed_app/README.md), and needs the
+> `whatsapp_business_management` permission.
+
+```ruby
+Whatsapp.configure do |config|
+  config.api_key = ENV.fetch("WHATSAPP_API_KEY")
+  config.waba_id = ENV.fetch("WHATSAPP_WABA_ID")
+end
+
+Whatsapp::BusinessPhoneNumber::Account::Get.call.name              # => "Acme Corp"
+Whatsapp::BusinessPhoneNumber::Account::Update.call(name: "Acme")  # => #<Response success=true>
+```
+
+| Method | Request | Returns |
+| --- | --- | --- |
+| `Get.call(client:, fields:)` | `GET /{waba_id}` | `Account::Details` |
+| `Update.call(client:, name:, timezone_id:)` | `POST /{waba_id}` | `BusinessPhoneNumber::Response` |
+
+Two independent actions, so two classes — the same shape as
+[subscribed apps](../subscribed_app/README.md), not the single-object CRUD of
+[templates](../message_templates/README.md).
+
+## Reading account details
+
+```ruby
+details = Whatsapp::BusinessPhoneNumber::Account::Get.call
+
+details.id     # => "102290129340398"
+details.name   # => "Acme Corp"
+```
+
+By default Meta returns only `id` and `name`. Ask for more with `fields:` — an Array or
+a String, comma-joined for you:
+
+```ruby
+Whatsapp::BusinessPhoneNumber::Account::Get.call(fields: %w[id name country])
+Whatsapp::BusinessPhoneNumber::Account::Get.call(fields: "id,name,country")
+```
+
+`Fields::ALL` requests everything Meta publishes, without hand-typing the list:
+
+```ruby
+details = Whatsapp::BusinessPhoneNumber::Account::Get.call(
+  fields: Whatsapp::BusinessPhoneNumber::Account::Get::Fields::ALL
+)
+```
+
+| Field | Description |
+| --- | --- |
+| `id` | The account's unique identifier |
+| `name` | Human-readable account name |
+| `timezone_id` | Timezone identifier |
+| `message_template_namespace` | Namespace the account's templates live in |
+| `account_review_status` | One of `Details::ReviewStatuses::ALL` |
+| `business_verification_status` | One of `Details::VerificationStatuses::ALL` |
+| `country` | Country code |
+| `ownership_type` | One of `Details::OwnershipTypes::ALL` |
+| `primary_business_location` | Primary business location |
+
+> `fields` is **not** validated against `Fields::ALL`. Those constants are for
+> convenience, not enforcement — a field Meta adds later works without a gem release.
+> Only what Meta documents as a *client-side* rule is checked locally.
+
+### Status values
+
+Statuses come back as plain strings, with frozen constants to compare against and three
+predicates for the checks you actually make:
+
+```ruby
+details.approved?     # => true   — account_review_status == "APPROVED"
+details.verified?     # => true   — business_verification_status == "VERIFIED"
+details.self_owned?   # => true   — ownership_type == "SELF"
+```
+
+| Constant | Values |
+| --- | --- |
+| `Details::ReviewStatuses::ALL` | `APPROVED` `DEFERRED` `PENDING` `REJECTED` |
+| `Details::VerificationStatuses::ALL` | `EXPIRED` `FAILED` `INELIGIBLE` `NOT_VERIFIED` `PENDING` `PENDING_NEED_MORE_INFO` `PENDING_SUBMISSION` `REJECTED` `REVOKED` `VERIFIED` |
+| `Details::OwnershipTypes::ALL` | `CLIENT_OWNED` `ON_BEHALF_OF` `SELF` |
+
+> Read-side values are never validated on the way in. A status Meta adds later still
+> round-trips untouched, so `details.account_review_status` is always exactly what the
+> API sent — same reasoning as
+> [`MessageTemplates::Response::Node#components`](../message_templates/responses.md).
+
+Every field is optional in the response, so anything you did not request is `nil`
+rather than an error.
+
+## Updating the account
+
+```ruby
+Whatsapp::BusinessPhoneNumber::Account::Update.call(name: "Acme Corporation").success
+# => true
+```
+
+| Field | Required | Rules |
+| --- | --- | --- |
+| `name` | no | Non-empty when given |
+| `timezone_id` | no | Non-empty when given. Meta publishes no enum — presence only |
+
+Both fields are optional, but **at least one must be present** — otherwise the request
+would spend a call to change nothing:
+
+```ruby
+Whatsapp::BusinessPhoneNumber::Account::Update.call
+# => ActiveModel::ValidationError: at least one of name or timezone_id must be provided
+
+Whatsapp::BusinessPhoneNumber::Account::Update.call(name: "")
+# => ActiveModel::ValidationError: Name can't be blank
+```
+
+An omitted field is compacted out of the body rather than sent as `null`, which Meta
+would read as an instruction to blank it:
+
+```ruby
+Whatsapp::BusinessPhoneNumber::Account::Update.new(name: "Acme Corp").serialize
+# => { name: "Acme Corp" }
+
+Whatsapp::BusinessPhoneNumber::Account::Update.new(name: "Acme Corp", timezone_id: "1").serialize
+# => { name: "Acme Corp", timezone_id: "1" }
+```
+
+`Update` returns the same `Whatsapp::BusinessPhoneNumber::Response` as the four
+onboarding actions — the endpoint answers with a bare `{ "success": true }`, so there is
+no separate response class for it.
+
+## Errors
+
+```ruby
+Whatsapp::BusinessPhoneNumber::Account::Get.call
+# => Whatsapp::BusinessPhoneNumber::Error: waba_id is required for business account
+#    details; set it via Whatsapp.configure or Client.new(waba_id:)
+
+# non-2xx response
+# => Whatsapp::BusinessPhoneNumber::Error: Failed to get business account details:
+#    404 Not Found - {"error":{"message":"WhatsApp Business Account not found",...}}
+```
+
+Both actions raise `Whatsapp::BusinessPhoneNumber::Error` — the same class the
+onboarding actions use, so one `rescue` covers the whole module. Local validation
+failures raise `ActiveModel::ValidationError` before any request. See
+[../errors.md](../errors.md).
+
+## Targeting a different account
+
+```ruby
+Whatsapp::BusinessPhoneNumber::Account::Get.call(
+  client: Whatsapp::Client.new(waba_id: "OTHER_WABA_ID")
+)
+```
+
+---
+
+**See also:** [Reading and updating the business profile](profile.md) ·
+[Registering business phone numbers](README.md)
+
+---
+
+**Meta docs:** <https://developers.facebook.com/documentation/business-messaging/whatsapp/reference/whatsapp-business-account/whatsapp-business-account-api>

data/docs/business_phone_number/contact_book.md

@@ -0,0 +1,90 @@
+# Contact book
+
+Meta keeps a **contact book** for your business portfolio: the phone numbers and BSUIDs
+of users you have interacted with. Its purpose is thread continuity — once a user adopts
+a username, Meta will keep putting their phone number in your webhooks if they are in
+your contact book, instead of leaving you with only their
+[BSUID](../webhooks/messages.md#business-scoped-user-ids-bsuid).
+
+The store itself is hosted by Meta and needs no integration work; entries appear on their
+own as you exchange messages or calls, and when a user taps a `REQUEST_CONTACT_INFO`
+button (which arrives as a [`contacts` message](../webhooks/messages.md#contacts) with
+`origin == "contact_request"`). This page covers the one operation Meta exposes on it:
+removing an entry.
+
+| Method | Request | Returns |
+| --- | --- | --- |
+| `ContactBook::Delete.call(bsuid:)` | `DELETE /{phone_id}/contact_book` | `ContactBook::Deletion` |
+
+## Deleting an entry
+
+```ruby
+result = Whatsapp::BusinessPhoneNumber::ContactBook::Delete.call(bsuid: "US.13491208655302741918")
+
+result.success  # => true  — the request was processed
+result.deleted  # => true  — an entry existed and is gone
+```
+
+The two booleans are independent, which is why this returns its own class rather than the
+shared `Response`:
+
+| `success` | `deleted` | Meaning |
+| --- | --- | --- |
+| `true` | `true` | An entry existed and was removed |
+| `true` | `false` | The request was fine; there was nothing stored for that BSUID |
+| `false` | — | The request was not processed |
+
+So `deleted == false` is **not** a failure. Check `success` for that, or rescue
+`Whatsapp::BusinessPhoneNumber::Error`.
+
+## What it affects
+
+> **The edge is on one phone number; the effect is portfolio-wide.** Contact books are
+> scoped to the business portfolio, so deleting an entry removes that user's phone number
+> from webhooks for **every** business phone number in the portfolio — not just the one
+> you addressed.
+
+And the consequence to expect: after a deletion, `wa_id`/`from` may start being omitted
+from your webhooks for that user, leaving their BSUID as the only identifier. That is the
+feature working, not a bug — but code that keys off `wa_id` will notice.
+
+The phone number can come back, without a new deletion, if the user messages or calls you
+again (or you them) within the 30-day window Meta caches, since that recreates the entry.
+
+## Rules
+
+- **Standard BSUIDs only.** Parent BSUIDs are not supported. Since this release hands you
+  `user_id` and `parent_user_id` side by side on half a dozen webhook classes, the mix-up
+  is easy, so it is caught locally:
+
+  ```ruby
+  Whatsapp::BusinessPhoneNumber::ContactBook::Delete.call(bsuid: "US.ENT.11815799212886844830")
+  # => ActiveModel::ValidationError: Bsuid looks like a parent BSUID;
+  #    the contact book accepts standard BSUIDs only
+  ```
+
+  Detected by segment count rather than by matching `ENT`, which would bet that `ENT` is
+  the only marker Meta will ever use.
+
+- **Same portfolio.** The BSUID must belong to the same portfolio as the phone number.
+  That is account state the gem cannot see, so it is left to the API — a mismatch comes
+  back as `Whatsapp::BusinessPhoneNumber::Error`.
+
+## Disabling the feature entirely
+
+The contact book can be turned off in **Meta Business Suite → Business settings →
+Business info**. Disabling it stops all storage and deletes everything already stored;
+re-enabling starts fresh, with no way to restore the old contents. There is no API for
+this, so it is not wrapped.
+
+## Not wrapped
+
+Meta documents only the delete on this edge. A future read or write belongs in this same
+namespace.
+
+---
+
+**See also:** [Business usernames](username.md) ·
+[BSUIDs in webhooks](../webhooks/messages.md#business-scoped-user-ids-bsuid)
+
+**Meta docs:** https://developers.facebook.com/documentation/business-messaging/whatsapp/business-scoped-user-ids