# Get a message template

`GET /v1/whatsapp/templates/{template_ref}`

Returns one template by its ID or slug: its lifecycle, the languages a send can currently resolve, a summary of where every language stands at Meta, and a pointer to the version that is live. Content is not here: read [a version](/docs/api/reference/get-whatsapp-template-version) for that.

## Code samples

### TypeScript

```ts
const tpl = await bird.whatsapp.templates.get("bird_otp");
console.log(tpl.default_language, tpl.live_version_id);
```

### Python

```py
tpl = client.whatsapp.templates.get("bird_otp")
print(tpl.default_language, tpl.available_languages)
```

### Go

```go
tpl, err := client.Whatsapp.Templates.Get(context.Background(), "bird_otp")
if err != nil {
	log.Fatal(err)
}
fmt.Println(tpl.DefaultLanguage, *tpl.AvailableLanguages)
```

### PHP

```php
$template = $bird->whatsapp->templates->get('bird_otp');
echo $template->getDefaultLanguage();
```

### CLI

```sh
bird whatsapp templates get <template-ref>
```

### cURL

```sh
curl -X GET "https://us1.platform.bird.com/v1/whatsapp/templates/{template_ref}" \
  -H "Authorization: Bearer $TOKEN"
```

## Example response `200`

```json
{
  "id": "wat_01krdgeqcxet5s7t44vh8rt9mg",
  "slug": "bird_otp",
  "name": "Order update",
  "description": "Sent when an order ships.",
  "scope": "system",
  "waba": "102290129340398",
  "category": "authentication",
  "status": "active",
  "default_language": "pt-BR",
  "on_missing_language": "fallback",
  "language_source_required": false,
  "available_languages": [
    "pt-BR"
  ],
  "languages": {
    "en": {
      "status": "approved"
    }
  },
  "draft_version_id": "wav_01krdgeqcxet5s7t44vh8rt9mg",
  "live_version_id": "wav_01krdgeqcxet5s7t44vh8rt9mg",
  "pending_version_id": "wav_01krdgeqcxet5s7t44vh8rt9mg",
  "last_submitted_at": "2026-07-26T16:40:00Z",
  "next": [
    {
      "kind": "operation"
    }
  ]
}
```

## Path parameters

- `template_ref` (string): Template ID (`wat_` prefix) or slug. A value that parses as a valid ID resolves by ID; any other value resolves as a slug.

## Response body

- `id` (string, required): Stable Bird identifier for the template.
- `slug` (string, required): The template's handle, editable before the first submission. Address it by this handle, and reference it when sending. Handles beginning with `bird_` are reserved for our built-in templates.
- `slug_editable` (boolean, required): Whether the slug can still be changed. False after the first submission and for built-in templates.
- `name` (string, required): A display name for the template. Nothing resolves through it, so it is safe to show wherever a human reads the template.
- `description` (nullable string, required): What the template is for. Null when unset.
- `scope` (string, required)

  Whether the template is one of our built-in templates (`system`) or one your workspace created (`workspace`).

  Possible values: `system`, `workspace`
- `waba` (string): The WhatsApp Business Account that holds this template's languages at Meta. Absent on a built-in template: those live on a WABA that Bird manages centrally rather than on your account, so it is not yours to reconcile against and is not disclosed.
- `category` (string, required)

  The category you declared for the template. It is fixed once the template exists. Meta applies its own category per language and may move one, which is what messages are priced at. Read the language for that.

  Possible values (may grow over time): `authentication`, `utility`, `marketing`
- `status` (string, required)

  The template's lifecycle, aggregated over its languages.

  Possible values: `draft`, `pending`, `active`, `rejected`, `inactive`
- `default_language` (string, required): The language a send falls back to when `on_missing_language` is `fallback`, and the language the template is required to hold.
- `on_missing_language` (string, required): What a send does when the language it asks for has no approved copy. Defaults to `fail` on WhatsApp, because every language is separately approved and separately priced: falling back silently would send content the recipient did not expect at a rate the sender did not choose.
- `language_source_required` (boolean, required): When true, a send must name a language explicitly rather than letting the template resolve one.
- `available_languages` (array of string, required): The languages a send can resolve right now: approved and not held back by Meta. It shrinks for reasons you did not cause: Meta pauses, disables, archives or limits a language and it leaves the set with nobody having edited anything. Read `languages` to see which languages exist and why one is missing.
- `languages` (object, required): Where each of the template's languages stands, keyed by BCP-47 language tag. This is the summary of the version currently in service, so a template reading `active` can still hold a rejected or paused language: the aggregate says something is sendable, and this says which. Content is not here; it lives under a version.
- `draft_version_id` (nullable string, required): The open draft, or null when nobody is editing. Non-null is the answer to whether this template has unsubmitted work: a draft exists only because someone opened one.
- `live_version_id` (nullable string, required): The version Meta is serving. A version goes live as a unit the moment any of its languages is approved, superseding the one before it. Null until a first approval.
- `pending_version_id` (nullable string, required): A submitted version still awaiting verdicts: what to poll. It stays set while any language is unresolved, including after a sibling's approval took the version live. Null when nothing is outstanding.
- `last_submitted_at` (nullable string, required): When this template was last submitted. Null for a pre-approved built-in template.
- `created_at` (nullable string, required): When the template was created. Null for a built-in template, which Bird ships rather than stores.
- `updated_at` (nullable string, required): When the template was last modified. Null for a built-in template, which Bird ships rather than stores.
- `next` (array of object)

  What to do next with this template, given the state it is in. Each entry names one
  action and says why it is worth taking, so you can act on this response without
  working out the order yourself. Present on reads that compute it: an empty list
  means there is nothing to do, and the field is absent entirely on responses that
  do not report next actions.

  A `draft` template routes to opening its draft, a `pending` one to the version
  under review, and a `rejected` or `inactive` one to a fresh draft. The template's
  `status` is the aggregate over its languages, so an entry may send you to the
  version to see where each language actually stands.
- `next.kind` (string, required)

  What you do about this step.

  - `operation`: call the operation named in `operation`, then
    read again.
  - `external`: act somewhere this API does not reach, then read
    again.
  - `wait`: nothing is asked of you, so read again later.
  - `terminal`: nothing you do resolves this, so stop retrying.

  Tolerate a value you do not recognize: show the `description` and
  offer no action.

  Possible values (may grow over time): `operation`, `external`, `wait`, `terminal`
- `next.description` (string, required): A short, human-readable label for the step, suitable for display.
- `next.operation` (string): The operationId to call. Present only when `kind` is `operation`. The operation's own schema says how to call it; this says only which one, and what to address it with.
- `next.params` (object): The parameters that address the operation, by name: `{"sender_id": "…"}` for an operation on `/v1/sms/senders/{sender_id}/requirements`. A parameter the operation takes in its query string is given the same way, so an operation addressed as `?subject_id=` carries `{"subject_id": "…"}`. Every parameter the call needs is here, whether its value came from the thing you were acting on or is fixed for this step, so you can make the call from this object alone. Present only when `kind` is `operation` and the operation names a subject. A request body, when the operation takes one, is described by the operation's own schema and never appears here.
- `next.url` (string): A URL to open. Present only when `kind` is `external`, and only when the step has one. An external step whose `description` says to go and do something with no URL to open is normal.

## Related resources

- [Should I use a Bird SDK or call the API directly?](/explained/platform/should-i-use-an-sdk-or-call-the-api-directly) (answer)
- [Build your first integration](/learn/paths/integration) (course)
- [Send your first email](/docs/get-started/send-your-first-email) (docs)

[Get an implementation brief](/learn/workspace?topic=api-basics)