---
title: "Resume a broadcast"
canonical: "https://bird.com/docs/api/reference/resume-email-broadcast"
---

# Resume a broadcast

`POST /v1/email/broadcasts/{broadcast_id}/resume`

Continues a `paused` broadcast using its saved template references and recipient list, skipping recipients already sent to and applying current consent and suppression checks for its saved category. Marketing broadcasts skip newly unsubscribed recipients; transactional broadcasts retain their category exemptions. Resuming does not use another broadcast from your monthly allowance. A `202` returns `status: sending`; delivery continues asynchronously. Use [get the broadcast](/docs/api/reference/get-email-broadcast) to follow progress.

If the broadcast first started sending at least 24 hours ago, review its message and set `confirm` to `true` to acknowledge late delivery. For older broadcasts without `started_at`, the threshold uses the send authorization time, or the creation time if neither timestamp was recorded. You can also send `confirm: true` before that threshold; it does not skip other checks. To review the message, use the broadcast's `template.id` and `template.version_id` with [get a template version](/docs/api/reference/get-email-template-version), then check `template.language` or the version's `default_language`. This requires `email_management:read`. Published workspace versions retain their original content and remain readable by ID after template deletion; a deleted or reused slug cannot identify the original message. A built-in template version lookup (`scope: system`) returns current catalogue content. Broadcasts with frozen content keep sending that content, but older broadcasts can read the catalogue again when resumed. Neither the current lookup nor a copy of an earlier message alone proves what remaining recipients will receive. Leave the broadcast paused unless you can verify that content. Once the funding wait has ended, adding funds alone does not restart a paused broadcast: call this operation explicitly after reviewing its content.

Returns `403` if the workspace is suspended or has been suspended since the original send authorization. `E04102` means a later suspension revoked this broadcast's authorization; reactivation does not restore it, so cancel the broadcast instead of retrying. Do not resend to its full audience without excluding recipients already sent to. Returns `402` if the account is blocked for insufficient funds, or `409` if the broadcast is not paused or needs late-delivery confirmation. A `422` can mean the concurrent broadcast limit is reached or the sender or IP pool needs repair. Read the error details, then wait for a free slot or repair the sender or pool and retry. A `429` can mean a sending limit prevents resuming. These refusals leave the broadcast paused. A `503` means the balance or email limits could not be checked; the broadcast stays paused and you can retry.

## Servers

- `https://{region}.platform.bird.com`: Regional API endpoint. Use the host for the region your organization is hosted in. Official Bird SDKs and the CLI select it automatically from your API key, so you rarely need to set it by hand.
  - `region`: `us1`, `eu1`. Default: `us1`. The region your organization's data is hosted in.

## Authentication

Use one authentication option:

- `BearerAuth`: HTTP bearer authentication. Pass the API key as a bearer token in the `Authorization` header. Workspace
keys use `bk_{region}_*`; organization master keys use `bm_{region}_*`.
The prefix identifies the region and selects the
API endpoint. Official Bird SDKs and the CLI derive the region from the key.

## Code samples

**TypeScript**

```ts
// Confirm only after verifying the content remaining recipients will receive and started_at. Leave unverifiable content paused.
const broadcast = await bird.broadcasts.resume(
  "eb_01krdgeqcxet5s7t44vh8rt9mg",
  { confirm: true },
);
console.log(broadcast.status);
```

Examples: [TypeScript](/docs/api/reference/resume-email-broadcast.ts.md) · [Python](/docs/api/reference/resume-email-broadcast.py.md) · [Go](/docs/api/reference/resume-email-broadcast.go.md) · [PHP](/docs/api/reference/resume-email-broadcast.php.md) · [CLI](/docs/api/reference/resume-email-broadcast.cli.md) · [MCP](/docs/api/reference/resume-email-broadcast.mcp.md) · [cURL](/docs/api/reference/resume-email-broadcast.curl.md)

## Example response `202`

```json
{
  "id": "eb_01krdgeqcxet5s7t44vh8rt9mg",
  "from": {
    "email": "jane@acme.com",
    "name": "Jane Doe"
  },
  "audience_id": "adn_01krdgeqcxet5s7t44vh8rt9mg",
  "template": {
    "id": "emt_01krdgeqcxet5s7t44vh8rt9mg",
    "version_id": "emv_01krdgeqcxet5s7t44vh8rt9mg"
  },
  "category": "marketing",
  "reply_to": [
    {
      "email": "jane@acme.com",
      "name": "Jane Doe"
    }
  ],
  "tags": [
    {
      "name": "category",
      "value": "welcome"
    }
  ],
  "track_opens": true,
  "track_clicks": true,
  "created_at": "2026-09-01T09:14:02.418Z",
  "status": "sending",
  "failure_reason": null,
  "failure_detail": null,
  "recipient_count": 4820,
  "started_at": "2026-09-02T08:00:03.771Z",
  "sent_at": null
}
```

## Path parameters

- `broadcast_id` (string, required): Broadcast identifier. Starts with `eb_`.

## Header parameters

- `Idempotency-Key` (string, optional)

  Client-supplied key. On operations supporting request deduplication, a retained
  response is replayed for duplicate requests with the same key within the
  idempotency window (3 hours by default). This protection requires a workspace,
  organization, or staff-account scope. User-only and unscoped unauthenticated operations,
  streams, and operations with a separate replay contract do not use this
  response replay.

  On a supported operation, if idempotency protection is unavailable before execution, the API returns
  `503 IdempotencyUnavailable` (E01033) without executing this attempt. Retry with
  backoff using the same key and request. An operation that takes effect before
  its response is retained can still execute again on retry.

  Two distinct 409 errors signal misuse:

  - `request_in_progress` (E01004): The same key is currently being
    processed by a concurrent request. Wait briefly and retry. The lock expires within 30 seconds.
  - `idempotency_key_reuse` (E01005): The same key has already completed
    against a different request body or method. Generate a new key.

  Recommended key format is `<event-type>/<entity-id>` (for example `welcome-user/usr_abc123`).
- `X-Workspace-Id` (string, optional): Workspace context for the request. Required for dashboard authentication and master keys. Workspace keys and access tokens already identify their workspace; send that workspace or omit the header. A different one is rejected.
- `X-Organization-Id` (string, optional): Organization context for the request. Required for dashboard authentication. An API key or access token carries its own organization, so send either that organization or no header at all; a different one is rejected.

## Request body

- `confirm` (boolean): Acknowledgment that the message reaches the remaining recipients later than intended. It is required to resume a broadcast that started sending at least 24 hours ago. Before setting it, read the broadcast's `started_at` and have a reviewer with `email_management:read` check its pinned template version using `template.id` and `template.version_id`. Workspace versions retain the original content. Built-in template lookups (`scope: system`) show current catalogue content. Broadcasts with frozen content keep it, but older broadcasts can read the catalogue again when resumed. Neither a current lookup nor an earlier message alone proves what remaining recipients will receive. Leave the broadcast paused unless you can verify that content. Ask an authorized teammate if you lack that permission. It does not skip the funds or concurrent-broadcast checks.

## Response body

- `id` (string, required): Broadcast ID.
- `display_label` (string): Label for selecting this broadcast on list and single-broadcast reads. With `email_management` read access, uses the retained subject from the template version resolved when execution starts, then its non-generated name. Draft and scheduled broadcasts use the name. Omitted when no authoritative label is available; clients can show a localized Untitled broadcast fallback. Without that access, uses the canonical broadcast ID. Absent from mutation responses.
- `from` (object): The address this broadcast sends from. `name` is filled in when the broadcast was given a display name to send under. Left out on a draft that has not picked a sender yet.
- `from.email` (string, required): Email address.
- `from.name` (string): Display name shown alongside the address in mail clients.
- `audience_id` (string): The audience this broadcast sends to. When the send starts we turn the audience into a list of recipients, and you can read that list a page at a time with [List recipients of a broadcast](/docs/api/reference/list-email-broadcast-recipients). Left out on a draft that has not picked an audience yet.
- `template` (nullable object): The template this broadcast sends, and the language it sends in. A broadcast sends the template's published version, and the exact version is fixed when the broadcast is prepared for sending, so publishing a new version afterwards does not change what this broadcast sends. Null on a draft that has not chosen a template yet.
- `template.id` (string, required): Which template the broadcast sends. Which version of it the send is fixed to is `version_id`.
- `template.language` (nullable string): The BCP-47 language tag selected for the whole audience, such as `en` or `pt-BR`. `null` means no language is selected, so the broadcast uses the published version's default language, unless the template has `language_source_required` set. Send `template.language` in an update to change or clear the selection.
- `template.version_id` (nullable string): The template version this broadcast is fixed to. It is chosen when the broadcast is prepared for sending, so publishing a new version while the broadcast is going out cannot change what the rest of the recipients get. Null until the broadcast is prepared.
- `template.parameters` (object): Complete template input map. Each value is a string, number, boolean or null and is used exactly as given, so text containing braces or code-like syntax is never evaluated. Objects and lists are not accepted. Use bird.contact.first_name in the template for contact data. Names must be bare input names outside the bird namespace. Omission retains the map unless the template ID changes, which clears it; an empty object clears it, and null is invalid. The compact map is limited to 16384 UTF-8 bytes and 128 names. Individual email parameters keep their own format.
- `template.parameter_overrides` (object): Complete map of per-language parameter values, keyed by a BCP-47 language tag of at most 35 characters such as `es` or `pt-BR`. Each language holds only the names whose value differs for that language; a name it leaves out uses the value in `parameters`, including later changes to it. A value that is present always applies, even when it is `""`, `0`, `false`, `null` or equal to the `parameters` value. To return a name to the `parameters` value, send the map without it. Sending this map, even as `{}`, applies language rules to the broadcast: `parameters` must hold every input the default language's content, sender name, reply-to or headers use, and an input only the selected language uses may come from that language's entry instead. A broadcast that never sends it keeps the selected-language rules. Values for the default language, or for a language the broadcast does not send, are kept but not used. Omission retains the map unless the template ID changes, which clears it; an empty object removes every override, null is invalid and a language with no names is removed. Tags are stored in canonical BCP-47 form, so two spellings of one tag are refused. The compact map is limited to 16384 UTF-8 bytes, and `parameters` and every language together are limited to 128 distinct names.
- `html_bytes` (integer): Size of the HTML body this broadcast sends, in bytes, or 0 when its content has no HTML part. Measured on the template version the broadcast sends, using the selected language. Recipient merge values can change its size. Returned on a single broadcast read, and absent from the list and from the broadcast that creating, updating, sending, resuming or canceling one returns, none of which measure the content. Absent too when the broadcast has no template or its content can no longer be read.
- `text_bytes` (integer): Size of the plain-text body this broadcast sends, in bytes, or 0 when its content has no plain-text part. Measured, and absent, the same way as `html_bytes`.
- `category` (string, required)

  What kind of email this is, which decides how suppressions apply to it. A `marketing` broadcast is held back from every suppressed address. A `transactional` one still goes to addresses suppressed for a complaint or an unsubscribe, because those suppressions are about marketing mail.

  Possible values: `marketing`, `transactional`
- `ip_pool_id` (string): The IP pool this broadcast sends from, or `ipp_shared` when it sends through the shared pool. Absent when it sends on your organization's default pool.
- `reply_to` (array of object): Where replies to this broadcast go, if you want them somewhere other than the `from` address. Absent when you have not set one.
- `reply_to.email` (string, required): Email address.
- `reply_to.name` (string): Display name shown alongside the address in mail clients.
- `headers` (object): Any custom email headers set on the broadcast. Returned on a single broadcast read and on the broadcast that creating, updating, sending, resuming or canceling one returns, and absent from the list. The unsubscribe headers we add ourselves are not included.
- `status` (string, required)

  Where the broadcast itself has got to, separate from what happened to individual recipients: for that, read `sent_count`, `delivered_count`, `bounced_count` and `complained_count` below. When it is `failed`, `failure_reason` says why. When it is `waiting_for_funds` or `paused`, `funding_hold` says why and what happens next.

  Possible values: `draft`, `scheduled`, `accepted`, `sending`, `waiting_for_funds`, `paused`, `sent`, `canceling`, `canceled`, `failed`
- `funding_hold` (object)

  Why sending stopped for funds and what happens next. Present only while `status` is `waiting_for_funds` or `paused`.

  The send-allowance response includes `can_start` when waiting and resuming are available. If `can_start` is absent, do not assume a top-up can recover a broadcast or that a failed broadcast can resume.

  Each interruption can wait up to 20 minutes for funds. Checks, refused batches and partial top-ups during the same interruption do not extend its deadline. Automatic continuation or an explicit resume clears the hold; if sending later stops for funds again, a new 20-minute wait begins.
- `funding_hold.reason` (string, required)

  Why sending stopped for funds.

  - `automatic_top_up`: Sending stopped while automatic top-up was active. Sending can continue automatically when a funding check succeeds before `wait_until`.
  - `funds_required`: Sending stopped because your balance cannot pay for more email. While `waiting_for_funds`, a manual or automatic top-up can restart sending before `wait_until`. If the broadcast is `paused`, add funds if needed, then resume it.
  - `wait_expired`: Status is `paused`. The automatic wait ended before sending continued. Add funds if needed, then resume the broadcast.

  Possible values: `automatic_top_up`, `funds_required`, `wait_expired`
- `funding_hold.wait_until` (string): When the automatic wait ends, or ended. Absent when the broadcast paused without waiting.
- `funding_hold.paused_at` (string): When the broadcast paused. Present only while `status` is `paused`.
- `next` (array of object)

  What to do next about this broadcast, given the state it is in. Each entry names one action and
  says why it is worth taking. Responses that compute next actions include this field: an empty list means there is
  nothing to do. Other responses omit it.
- `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.
- `failure_reason` (nullable string)

  Why the broadcast failed. Set when `status` is `failed`, and `null` the rest of the time.

  - `empty_audience`: There was nobody to send to. Either the audience has no members, or every address in it is suppressed.
  - `audience_unavailable`: The audience no longer exists, so there was nothing to resolve.
  - `content_invalid`: The broadcast could not be set up to send. `failure_detail` explains what went wrong. It is one of these:
    - The broadcast has no template, or the template it uses no longer exists. Choose an existing template and send the broadcast again.
    - The template has no published version, or its published version has no subject and no body. Publish the template, or add content and publish it.
    - The template uses a loop or reads a value that a broadcast cannot provide. Remove it, or use a contact property instead, then publish the template again.
    - The template requires a language, but the broadcast has not selected one. Set `template.language` to one of the template's languages and send the broadcast again.
    - The selected language is not available on the published template version. Choose one of that version's languages, or publish a version that includes the selected language.
    - The sending domain is no longer verified. Verify the domain again.
    - The configured IP pool has no usable IP address.
    - We could not hand the prepared message to the delivery system. This is a problem on our side.
  - `insufficient_funds`: There was not enough in the workspace balance to pay for the send.
  - `quota_exceeded`: The send would have gone past your organization's daily or monthly email allowance, whichever runs out first. This can happen when the broadcast is being prepared, or partway through sending if the remaining recipients no longer fit. `failure_detail` gives you the count and the limit.
  - `internal_error`: Something went wrong on our side. Retry, and open a support ticket if it keeps happening.
  - `workspace_suspended`: The workspace is suspended, so the broadcast stopped sending. Recipients not yet sent to are not sent to, even after reactivation. Contact Bird support to reactivate the workspace.

  Possible values: `empty_audience`, `audience_unavailable`, `content_invalid`, `insufficient_funds`, `quota_exceeded`, `internal_error`, `workspace_suspended`, `null`
- `failure_detail` (nullable string): A sentence explaining the failure in more detail than `failure_reason` does, and `null` when the broadcast has not failed. Show it to the person using your app. Do not write code that reads it, because the wording can change. Branch on `failure_reason` instead.
- `recipient_count` (integer, required): Number of recipients after suppressed addresses are removed from the audience. This is 0 until sending starts and the audience becomes a recipient list.
- `sent_count` (integer): How many recipients the broadcast has been sent to, counting every recipient whose status is `processed` or later. The number rises while the broadcast is `sending` and stops changing once the broadcast has finished. These counters are exact. The email stats endpoints report on the same sending but are approximate, so use these numbers when you need the precise count. Absent when the broadcast comes back from creating, updating, sending, resuming or canceling it, none of which read the counters. List and single-broadcast reads return 0 when no delivery events are recorded. When counters are unavailable, those reads still return 200 and omit the counters. Read the broadcast again for the numbers.
- `delivered_count` (integer): How many recipients' messages were accepted by their mail server. Absent when `sent_count` is.
- `bounced_count` (integer): How many recipients the message could not be delivered to at all. Absent when `sent_count` is.
- `complained_count` (integer): How many recipients marked the message as spam. Absent when `sent_count` is.
- `open_count` (integer): How many times the message was opened, added up across every recipient. One recipient opening it twice counts twice. Absent when `sent_count` is.
- `click_count` (integer): How many times a link in the message was clicked, added up across every recipient. One recipient clicking twice counts twice. Absent when `sent_count` is.
- `sending_ips` (array of string): The IP addresses this broadcast's messages went out from, up to 100 of them. A broadcast is spread across every address in its pool, so more than one can appear. The receiving mail systems name the address when they deliver, bounce or defer a message, so this stays absent until the first of those comes back. Returned on a single broadcast read, and absent from the list and from the broadcast that creating, updating, sending, resuming or canceling one returns, none of which read them. For delivery and latency broken down per address, read the sending-IP stats.
- `unique_opens_non_prefetched` (integer): How many distinct recipients opened the message at least once, excluding opens auto-fetched by inbox privacy features (such as Apple Mail Privacy Protection and the Gmail image proxy). A recipient who opened several times, or whose inbox prefetched the message, counts once. Absent when `sent_count` is.
- `unique_clicks` (integer): How many distinct recipients clicked a link in the message at least once. A recipient who clicked several times counts once. Absent when `sent_count` is.
- `out_of_band_bounces` (integer): How many recipients bounced after the message had already been accepted for delivery. A recipient who bounced this way more than once counts once. Absent when `sent_count` is.
- `delivered_recipients` (integer): How many distinct recipients a delivery landed for. This is the denominator to measure `unique_opens_non_prefetched`, `unique_clicks` and `complained_count` against. It differs from `delivered_count`, which reports how many recipients are currently in the delivered state: a recipient who was delivered to and then complained moves to `complained_count` and leaves `delivered_count`, but stays here, because the message did reach them. Absent when `sent_count` is.
- `tags` (array of object): Labels on this broadcast, each one a `name` and a `value`, that you can filter and search broadcasts by. Use tags for anything you want to find broadcasts by later, and `metadata` for data you only want handed back to you.
- `tags.name` (string, required): Tag name. ASCII letters, digits, underscore, and hyphen only. Case-sensitive. Maximum 32 characters.
- `tags.value` (string, required): Tag value. ASCII letters, digits, underscore, and hyphen only. Case-sensitive. Maximum 64 characters.
- `metadata` (object): Any JSON you want to keep on the broadcast. We store it and hand it back in webhook payloads, and that is all it does. If you want to search or filter by it, use `tags` instead.
- `track_opens` (boolean, required): Whether opens are tracked for this broadcast.
- `track_clicks` (boolean, required): Whether link clicks are tracked for this broadcast.
- `created_at` (string, required): When the broadcast was created.
- `scheduled_at` (string): When the broadcast is due to send, and absent when it is not scheduled.
- `started_at` (string): When the broadcast started sending. Absent until then. Older broadcasts waiting or paused for funds may lack that timestamp; they report their send authorization time, or creation time if that is also missing, so late-resume confirmation uses the same conservative time as the server. Compare with `sent_at`, which is when the broadcast finished sending.
- `sent_at` (nullable string, required): When the last recipient was sent to and the broadcast became `sent`. Null until then. Compare with `started_at`, which is when the broadcast started sending.
- `canceled_at` (string): When the broadcast was canceled, and absent if it never was. This is when cancellation was requested, so it is set as soon as the status is `canceling` and does not move while the remaining sends stop and the status becomes `canceled`.
- `failure_parameters` (object)

  Why the broadcast failed, when it could not prepare or render its template inputs. A failed broadcast cannot be updated or sent again. Correct the input or template that `pointer` and `problems` name, then create a new broadcast with the corrected inputs and send it. When `code` is `transport_missing` or `transport_invalid`, the broadcast's saved content cannot be used and changing an input does not fix it, so contact Bird support.

  Absent when the broadcast did not fail this way. Returned on a single broadcast read and on the broadcast that creating, updating, sending, resuming or canceling one returns, and absent from the list.
- `failure_parameters.code` (string, required)

  What a broadcast input diagnostic found.

  - `parameter_json_invalid`: the request body or an input map is not valid JSON.
  - `parameter_map_invalid`: `template.parameters` or `template.parameter_overrides` is not a JSON object of input names.
  - `parameter_name_invalid`: an input name is not a bare name outside the `bird` namespace.
  - `parameter_value_unsupported`: an input value is an object or a list. Values must be a string, number, boolean or null.
  - `parameter_duplicate_key`: an input name, or two spellings of one language tag, appears twice.
  - `parameter_bytes_exceeded`: an input map is larger than 16384 UTF-8 bytes.
  - `parameter_names_exceeded`: `template.parameters` and every language together hold more than 128 distinct names.
  - `parameter_depth_exceeded`: an input value is nested too deeply.
  - `parameter_language_invalid`: a `template.parameter_overrides` key is not a valid BCP-47 language tag.
  - `parameter_required`: the template or envelope uses an input that has no value.
  - `sensitive_input_unsupported`: the template uses an input it marks sensitive, which a broadcast cannot supply.
  - `render_profile_unsupported`: the template uses a Liquid operation that rendering with broadcast inputs does not support.
  - `rendered_envelope_invalid`: the rendered subject, sender name, reply-to addresses or a header is not valid for an email, for example because it contains a line break.
  - `contact_property_unknown`: the template reads a contact property this workspace has not defined.
  - `template_unavailable`: the broadcast has no template, or its template no longer exists or has no published version.
  - `language_unavailable`: the published version has no content in the selected language.
  - `sender_unavailable`: the broadcast cannot send from its `from` address or IP pool.
  - `audience_unavailable`: the broadcast's audience cannot be used for this send.
  - `recipient_render_failed`: content could not be rendered for a recipient while the broadcast was sending.
  - `render_budget_exceeded`: rendering went over a limit, named by `budget` with its `limit`.
  - `transport_missing`: the saved content of a prepared broadcast is unavailable. Contact Bird support.
  - `transport_invalid`: the saved content of a prepared broadcast no longer matches what was prepared. Contact Bird support.

  Possible values (may grow over time): `parameter_json_invalid`, `parameter_map_invalid`, `parameter_name_invalid`, `parameter_value_unsupported`, `parameter_duplicate_key`, `parameter_bytes_exceeded`, `parameter_names_exceeded`, `parameter_depth_exceeded`, `parameter_language_invalid`, `parameter_required`, `sensitive_input_unsupported`, `render_profile_unsupported`, `rendered_envelope_invalid`, `contact_property_unknown`, `template_unavailable`, `language_unavailable`, `sender_unavailable`, `audience_unavailable`, `recipient_render_failed`, `render_budget_exceeded`, `transport_missing`, `transport_invalid`
- `failure_parameters.phase` (string, required)

  Where a broadcast input diagnostic was found.

  - `request`: in the inputs this request supplied, before the template was checked.
  - `validation`: while checking the inputs against the current published template, as validate, preview and send do.
  - `execution`: while the broadcast was being prepared or sent. This phase appears on `failure_parameters`.

  Possible values (may grow over time): `request`, `validation`, `execution`
- `failure_parameters.pointer` (string): A JSON pointer to the broadcast field the failure is about, such as `/template/parameters/first_name` or `/template`.
- `failure_parameters.observed_version_id` (string): The published template version the broadcast was using when it failed. Absent when no version had been selected.
- `failure_parameters.problems` (array of object): Up to 20 of the problems found. A recipient problem names its contact in `contact_id`.
- `failure_parameters.problems.code` (string, required)

  What a broadcast input diagnostic found.

  - `parameter_json_invalid`: the request body or an input map is not valid JSON.
  - `parameter_map_invalid`: `template.parameters` or `template.parameter_overrides` is not a JSON object of input names.
  - `parameter_name_invalid`: an input name is not a bare name outside the `bird` namespace.
  - `parameter_value_unsupported`: an input value is an object or a list. Values must be a string, number, boolean or null.
  - `parameter_duplicate_key`: an input name, or two spellings of one language tag, appears twice.
  - `parameter_bytes_exceeded`: an input map is larger than 16384 UTF-8 bytes.
  - `parameter_names_exceeded`: `template.parameters` and every language together hold more than 128 distinct names.
  - `parameter_depth_exceeded`: an input value is nested too deeply.
  - `parameter_language_invalid`: a `template.parameter_overrides` key is not a valid BCP-47 language tag.
  - `parameter_required`: the template or envelope uses an input that has no value.
  - `sensitive_input_unsupported`: the template uses an input it marks sensitive, which a broadcast cannot supply.
  - `render_profile_unsupported`: the template uses a Liquid operation that rendering with broadcast inputs does not support.
  - `rendered_envelope_invalid`: the rendered subject, sender name, reply-to addresses or a header is not valid for an email, for example because it contains a line break.
  - `contact_property_unknown`: the template reads a contact property this workspace has not defined.
  - `template_unavailable`: the broadcast has no template, or its template no longer exists or has no published version.
  - `language_unavailable`: the published version has no content in the selected language.
  - `sender_unavailable`: the broadcast cannot send from its `from` address or IP pool.
  - `audience_unavailable`: the broadcast's audience cannot be used for this send.
  - `recipient_render_failed`: content could not be rendered for a recipient while the broadcast was sending.
  - `render_budget_exceeded`: rendering went over a limit, named by `budget` with its `limit`.
  - `transport_missing`: the saved content of a prepared broadcast is unavailable. Contact Bird support.
  - `transport_invalid`: the saved content of a prepared broadcast no longer matches what was prepared. Contact Bird support.

  Possible values (may grow over time): `parameter_json_invalid`, `parameter_map_invalid`, `parameter_name_invalid`, `parameter_value_unsupported`, `parameter_duplicate_key`, `parameter_bytes_exceeded`, `parameter_names_exceeded`, `parameter_depth_exceeded`, `parameter_language_invalid`, `parameter_required`, `sensitive_input_unsupported`, `render_profile_unsupported`, `rendered_envelope_invalid`, `contact_property_unknown`, `template_unavailable`, `language_unavailable`, `sender_unavailable`, `audience_unavailable`, `recipient_render_failed`, `render_budget_exceeded`, `transport_missing`, `transport_invalid`
- `failure_parameters.problems.phase` (string, required)

  Where a broadcast input diagnostic was found.

  - `request`: in the inputs this request supplied, before the template was checked.
  - `validation`: while checking the inputs against the current published template, as validate, preview and send do.
  - `execution`: while the broadcast was being prepared or sent. This phase appears on `failure_parameters`.

  Possible values (may grow over time): `request`, `validation`, `execution`
- `failure_parameters.problems.severity` (string, required)

  How a broadcast input diagnostic affects sending.

  - `error`: the broadcast cannot send until the problem is fixed.

  Possible values (may grow over time): `error`
- `failure_parameters.problems.pointer` (string): A JSON pointer to the request or broadcast field the problem is about, such as `/template/parameters/first_name` or `/from`. Absent when the problem is not about one field.
- `failure_parameters.problems.site` (string)

  Where in the email the input is used. Absent when the problem is not tied to one place.

  Possible values (may grow over time): `subject`, `html`, `text`, `from_name`, `reply_to`
- `failure_parameters.problems.budget` (string): The rendering limit that was exceeded, such as `output_bytes` or `nesting`, when `code` is `render_budget_exceeded`. It is reported with `limit` on problems from sending a broadcast, in `failure_parameters`.
- `failure_parameters.problems.limit` (integer): The value of the limit named by `budget`.
- `failure_parameters.problems.contact_id` (string): The contact whose values were being rendered, when the problem came from one recipient.
- `failure_parameters.failure_count` (integer, required): How many recipients failed to render, including those not listed in `problems`. It can be `0` when the broadcast failed while it was being prepared, before any recipient was rendered.

## 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)