---
title: "Send the contact's confirmation link again"
canonical: "https://bird.com/docs/api/reference/send-workspace-compliance-submission-contact-confirmation"
---

# Send the contact's confirmation link again

`POST /v1/compliance/submissions/{submission_id}/contact-confirmation`

Emails the business contact of a business verification a new confirmation link, for a
submission whose `contact_email` is `awaiting_confirmation`. The previous link stops working.
To use another address, resupply `contact_email` instead; that sends a link to the new
address.

Returns `409 Conflict` when the submission is not waiting for its contact to confirm.

## 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
const submission = await bird.complianceSubmissions.sendContactConfirmation(
  "csb_01krdgeqcxet5s7t44vh8rt9mg",
);
console.log(submission.id);
```

Examples: [TypeScript](/docs/api/reference/send-workspace-compliance-submission-contact-confirmation.ts.md) · [Python](/docs/api/reference/send-workspace-compliance-submission-contact-confirmation.py.md) · [Go](/docs/api/reference/send-workspace-compliance-submission-contact-confirmation.go.md) · [PHP](/docs/api/reference/send-workspace-compliance-submission-contact-confirmation.php.md) · [CLI](/docs/api/reference/send-workspace-compliance-submission-contact-confirmation.cli.md) · [MCP](/docs/api/reference/send-workspace-compliance-submission-contact-confirmation.mcp.md) · [cURL](/docs/api/reference/send-workspace-compliance-submission-contact-confirmation.curl.md)

## Example response `200`

```json
{
  "next": [
    {
      "kind": "operation"
    }
  ],
  "id": "csb_01krdgeqcxet5s7t44vh8rt9mg",
  "subject_kind": "sms_sender",
  "subject_id": "scr_01krdgeqcxet5s7t44vh8rt9mg",
  "program": "alpha",
  "country_code": "US",
  "identity_id": "cid_01krdgeqcxet5s7t44vh8rt9mg",
  "domain_proof": {
    "method": "member_login",
    "domain": "acme.com"
  },
  "verifying_user_id": "usr_01krdgeqcxet5s7t44vh8rt9mg",
  "items": [
    {
      "id": "cit_01krdgeqcxet5s7t44vh8rt9mg",
      "state": "not_supplied",
      "attachment_id": "tca_01krdgeqcxet5s7t44vh8rt9mg",
      "attachment_ids": [
        "tca_01krdgeqcxet5s7t44vh8rt9mg"
      ]
    }
  ]
}
```

## Path parameters

- `submission_id` (string, required): Submission ID.

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

## Response body

- `next` (array of object)

  What to do next about this submission, 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 submission reports the answers you filed; whether the country's requirements are met is
  reported by the requirements read. So this points there rather than repeating a verdict it
  does not own.
- `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.
- `id` (string, required)
- `subject_kind` (string, required)

  What is being registered.

  - `sms_sender`: a sender registered to send to one country.
  - `number`: a phone number you hold that needs ownership paperwork before it
    can carry traffic.
  - `number_emergency`: emergency calling on a dedicated number you hold. The
    subject is created by turning emergency calling on for the number.
  - `identity`: a business you operate as, registered once and reused by
    later registrations that name it.

  Possible values: `sms_sender`, `number`, `number_emergency`, `identity`
- `subject_id` (string, required): What is being registered. For `sms_sender` this is the `scr_` id returned when you register a sender for a country. For `number` it is the `nda_` id of a dedicated number you hold, as returned by `GET /v1/numbers`. For `number_emergency`, it is the `nes_` ID of the emergency service being registered. A shared short code (`nal_`) is not accepted: it is shared, so its ownership paperwork is not yours to file. For `identity` it is the `cid_` id of the party being registered, picked from the parties your workspace holds, as returned by `GET /v1/compliance/identities`.
- `program` (string, required)

  The registration program a country runs. Available programs depend on the registered resource. An SMS sender registers under an authority regime (`alpha` or `numeric`). A phone number proves ownership under its number type (`mobile`, `local`, `national`, `short_code`, `short_code_fteu`, or `toll_free`), matching the values of `NumberType`. An identity registers your business itself under `business`, internationally: its coordinate's country is always `ZZ`. A value is therefore only meaningful alongside the subject it describes. More are added as coverage grows, so treat this as an open set rather than a fixed list.

  Possible values (may grow over time): `alpha`, `numeric`, `mobile`, `local`, `national`, `short_code`, `short_code_fteu`, `toll_free`, `business`
- `country_code` (string, required): ISO 3166-1 alpha-2 country code.
- `identity_id` (nullable string, required): The party this registration was filed for, or `null` if none was named.
- `domain_proof` (object): For a business verification, how your organization proved it controls the business's domain. Absent otherwise.
- `domain_proof.method` (string, required)

  How the domain was proven.

  - `member_login`: a member of this workspace signs in with a verified address at the domain.
  - `sso_domain`: the domain is your organization's verified single sign-on domain.
  - `contact_confirmation`: the business contact confirmed a link we emailed to their address at the domain.

  Possible values (may grow over time): `member_login`, `sso_domain`, `contact_confirmation`
- `domain_proof.domain` (string, required): The business's registrable domain, such as `acme.com`.
- `verifying_user_id` (string): For a business verification, the member who acts for the business. Absent otherwise.
- `satisfied` (boolean, required): Whether this country's requirements are met. `true` once the submission is approved and every required requirement is approved or marked not applicable. This can remain true when an external verifier requests a correction. Once you submit that correction, it must pass review before this becomes true again, including any optional answers you change.
- `items` (array of object, required): Every answer and where it stands. Each is decided on its own.
- `items.inherited` (boolean, required): `true` when this answer was accepted without a fresh review, because the same answer to the same requirement had already been approved for this party in this country. It carries the original verdict, including when that verdict expires.
- `items.id` (string, required)
- `items.key` (string, required): The requirement this answers.
- `items.state` (string, required)

  Where one requirement stands. The `not_supplied` state means nothing has been
  given for it yet. The `supplied` state means we have your answer and review
  has not started. The `in_review` state means someone is looking at it. The
  `approved` and `rejected` states are decisions. You can replace a rejected
  item without refiling the rest. The `not_applicable` state means this
  requirement does not apply to you. The `expired` state means the value was
  accepted but has since gone stale. The `awaiting_confirmation` state is a
  business contact we emailed a confirmation link to: nothing is reviewed until
  they confirm, and you can resend the link or give another address.

  An item only ever reports its state. Treat this as an open set because review
  can gain stages. A value you do not recognise is a valid state that this
  server added.

  Possible values (may grow over time): `not_supplied`, `supplied`, `in_review`, `approved`, `rejected`, `not_applicable`, `expired`, `awaiting_confirmation`
- `items.value` (nullable string, required): Your answer, for a requirement answered inline. Every answer travels as a string whatever its data type, so a number reads back as `"1500"` and a yes-or-no as `"true"`. Use the data type to parse it. `null` for a requirement that takes a document.
- `items.attachment_id` (nullable string, required): The document you supplied, for a requirement that takes one. `null` otherwise.
- `items.values` (nullable array, required): Your answers, for a requirement that takes several and is answered inline. `null` for one answered once. Order is as you sent it.
- `items.attachment_ids` (nullable array, required): The documents you supplied, for a requirement that takes several. `null` otherwise.
- `items.reason` (nullable string, required): Why this was rejected, when it was. `null` otherwise.
- `items.decided_at` (nullable string, required): When this was decided. `null` while no decision has been made.
- `items.expires_at` (nullable string, required): When this answer goes stale and must be supplied again. `null` when it does not expire.
- `created_at` (string, required): When this was submitted.
- `updated_at` (string, required): When it last changed.
- `closed_at` (nullable string): When this submission was closed. Null while it remains open.
- `closure_reason` (nullable string): The decline reason for a closed submission, or null while open.

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