> For the complete documentation index, see [llms.txt](https://docs.concurrence.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.concurrence.com/developer-guide/reference-guides/reconcile-channel-manager.md).

# Reconcile a Channel Manager Attempt

Recover Channel Manager message and call IDs after an uncertain response, paginate records, and distinguish acceptance from delivery before deciding what to do next.

A timeout leaves the outcome unknown. Your request may have reached the channel even when your application has no response or resource ID. Pause automatic resends while you investigate. Channel Manager message sends do not accept a client-supplied idempotency key.

Complete [Channel Manager setup and authentication](https://docs.concurrence.com/pages/TWFPrOxAvAp4FKKfh07v#id-1.-verify-scoped-access) first. This guide uses Bash, cURL, and `jq`, with `CHANNEL_API_BASE`, `CHANNEL_ACCESS_TOKEN`, `CHANNEL_SETUP_ID`, and `CHANNEL_USE_CASE_ID` from that setup. Use the affected channel's read scope: `sms:read`, `email:read`, `imessage:read`, or `voice:read`.

## Preserve the Attempt

Before sending, record your workflow ID, setup and use case, intended recipient, attempt time, and an appropriate content reference in your application. Store the returned Channel Manager ID as soon as you receive it. Keep this record even if the request fails locally.

If you have the ID, use the [individual message or call read](https://docs.concurrence.com/developer-guide/platform-api/conversations/channel-manager.md) to inspect its state. If you have no ID, search the channel's records below. A matching recipient alone is insufficient when several workflows contact the same person.

## Find Candidate Records

Set `CHANNEL_KIND` to `sms`, `email`, `imessage`, or `voice`. Set `CHANNEL_PEER` to the recipient's E.164 phone number, or their email address for email. This read-only example lists outbound records for that use case and recipient, following every returned page:

```bash
set -euo pipefail
case "$CHANNEL_KIND" in
  sms)      channel_path='/v1/sms';         peer_field='peer_phone_number' ;;
  email)    channel_path='/v1/email';       peer_field='peer_address' ;;
  imessage) channel_path='/v1/imessage';    peer_field='peer_number' ;;
  voice)    channel_path='/v1/voice-call/'; peer_field='peer_number' ;;
  *) printf 'Choose sms, email, imessage, or voice\n' >&2; exit 1 ;;
esac

query=(
  --data-urlencode "setup_id=$CHANNEL_SETUP_ID"
  --data-urlencode "use_case_id=$CHANNEL_USE_CASE_ID"
  --data-urlencode 'direction=outbound'
  --data-urlencode "$peer_field=$CHANNEL_PEER"
  --data-urlencode 'limit=50'
)

cursor=''
while :; do
  request_query=("${query[@]}")
  if [ -n "$cursor" ]; then
    request_query+=(--data-urlencode "continuation_token=$cursor")
  fi
  page=$(curl --fail-with-body --silent --show-error --get \
    "$CHANNEL_API_BASE$channel_path" \
    --header "Authorization: Bearer $CHANNEL_ACCESS_TOKEN" \
    "${request_query[@]}")
  printf '%s' "$page" | jq -c '.items[]'
  if ! printf '%s' "$page" | jq -e '.has_more == true' >/dev/null; then
    break
  fi
  cursor=$(printf '%s' "$page" | jq -er \
    '.continuation_token | select(. != null) | tostring')
done
unset page cursor
```

Run this only in an approved environment, because candidate rows can contain message content and contact information. Keep the filters unchanged between pages. Treat `continuation_token` as opaque. Pass it back rather than deriving your own value.

SMS, email, and voice also support `created_after` and `created_before` for a bounded search. Use timezone-qualified timestamps that bracket the attempt with margin. iMessage uses `occurred_at` in its returned records, so inspect those timestamps locally. These feeds are not a fixed snapshot, so repeated reads can be necessary while new activity arrives.

For a voice call whose creation response is missing, also search **without** the peer filter. Creating a call does not dial anyone, and the record can have no peer number. If you already know `call_ref` but a participant-add response is missing, read that call's participants before attempting to add another leg.

The canonical [Channel Manager reference](https://docs.concurrence.com/developer-guide/platform-api/conversations/channel-manager.md) embeds the list and detail contracts. WhatsApp investigation uses the channel-operations handoff agreed during provisioning. These list examples apply to SMS, email, iMessage, and voice.

## Decide From the Evidence

Match the setup, use case, direction, recipient, time, and available content or call participants to your attempt. Save a confidently matched `id` or `call_ref` against your workflow, then read that resource individually.

| Observation                               | Next action                                                                                                        |
| ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
| A matching message is accepted or pending | Track its status and avoid issuing the same send again.                                                            |
| Delivery or a terminal error is recorded  | Update your workflow from that channel's result. Check suppression and the error before considering a new attempt. |
| A call or participant exists              | Inspect join, leave, dial, and end state. Resource creation does not prove a person answered.                      |
| Several records could match               | Preserve the ambiguity and involve the channel operator before another external action.                            |
| No record matches                         | Keep the outcome unknown. An empty search is not proof that no external send or call occurred.                     |

For email, delivery means the receiving mail server accepted the message. Opens and clicks do not prove a business outcome. For iMessage, inspect the reported `service`, downgrade, and error fields as well as timestamps. For voice, distinguish a dial result from joining the conference and from human-answer classification.

Channel records cover Channel Manager's managed channels. A ticket, message, or other delivery sent through an external integration tool needs that integration's own reconciliation procedure.

## Verify the Recovery Path

With a controlled recipient and synthetic content, send one test message and deliberately omit its returned ID from your application's recovery input. Find it through the list, read it, and link the ID back to the original attempt. Verify that recovery itself sends nothing. This exercises missing-response handling without deliberately disrupting a live request.

For an unresolved attempt, give your support owner the setup and use-case IDs, intended recipient, attempt window, known Channel Manager IDs, and error details through an approved support channel. Leave out credentials and unnecessary content. Retain the investigation record under your data policy, close the test workflow, and remove temporary tokens from your shell.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.concurrence.com/developer-guide/reference-guides/reconcile-channel-manager.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
