Build with

Overview

Voiceflow integrates with Freshchat so AI agents can recognize customers, create and follow up on support conversations, answer from approved FAQs and connect customers with your support team.

Use API tools for Freshchat data, Knowledge for approved FAQ content and a Custom Handoff relay for two-way human support. Each has its own setup: authorizing a data tool does not import FAQs or start live handoff. Freshchat uses conversations and topics; these instructions use the Freshchat API, not the Freshdesk ticket API.

Examples of when to use Freshchat

Studio

Use an editable Voiceflow project and ask your Freshchat administrator for the account’s API URL and token. Your application developer supplies verified customer IDs and prepared write payloads; live handoff also needs a deployed relay.

Code

Use Voiceflow’s management API or CLI to create, test and attach tools. Your backend verifies customer/case access, prepares payloads and hosts the optional relay. Keep the account-wide Freshchat token on the server.

Connecting Freshchat

Authorize your account and test a customer lookup before enabling writes.

Have a Freshchat account administrator open Admin settings → APIs for chat → Generate Token. Obtain the account’s API URL from those settings; use its host throughout these examples instead of assuming a global or Freshdesk host. Freshsales Suite also exposes chat API details under its API settings. Requests use Authorization: Bearer TOKEN; store only TOKEN in the restricted Secret freshchat_token.

The token grants access to your account’s user and conversation data. Use a test account for initial writes. Freshchat permits one generated token at a time: deleting it to generate a replacement interrupts consumers of the previous token. Coordinate that replacement across your tools and relay. See Freshchat API tokens.

Prepare and test a customer lookup

Studio

1

Store the credential

Open the project in Agent studio. In the left sidebar, open More → Secrets and create freshchat_token with the Freshchat token. Creating the default also sets Main’s Published value, so use a test project. Set an override for your test Environment’s Draft when it uses a different credential.

2

Create the API tool

Open Agent → Global tools → + → API, then create Find Freshchat customer. Choose GET and set the URL to https://YOUR_ACCOUNT.freshchat.com/v2/users/{user_id}. Add the header Authorization with value Bearer {api_token} and Accept: application/json.

Configure the Freshchat request in the API tool editor. Photo:
3

Bind trusted inputs and test

First create freshchat_user_id in More → Variables, leaving its default empty. Have your developer pass variables: {"freshchat_user_id":"VERIFIED_FRESHCHAT_ID"} with the authenticated backend’s initial launch action; creating a session alone does not populate it. Obtain a verified test user ID from them. Return to the tool, set the api_token input’s default to the Secret freshchat_token, and bind user_id to that identity variable rather than asking the model to choose a customer. Test that user ID, inspect the response and capture only the fields your support task needs.

Before publishing a tested tool, select the target Environment and open freshchat_token in More → Secrets. Set its Default value to the credential that Environment’s published agent should use; Draft value alone does not supply it. Follow Secret publication behavior, then publish the tested agent.

Code

Create a personal or service key with access to the project and set it as VF_TOKEN. Set PROJECT_ID to that project’s ID and ENVIRONMENT to the alias shown on its Environments page. Use a test Environment. Set FRESHCHAT_TOKEN to your Freshchat API token and FRESHCHAT_USER_ID to a Freshchat user ID verified by your application. Use a current Voiceflow CLI with API-tool and tool commands; it reads VF_TOKEN.

Save this definition as freshchat-tool.json, replacing YOUR_ACCOUNT.freshchat.com with the host from your account API URL. Braced names declare API-tool inputs, not project Secrets:

1

Create the Secret and identity variable

Creating this Secret sets its project default and Main’s Published value. Use a test project, then set the intended Draft override:

Save secret.id as SECRET_ID:

Send variables: {"freshchat_user_id":"VERIFIED_FRESHCHAT_ID"} from your backend with the initial launch action. The action applies these variables before the turn; session creation alone does not set them. Do not set a shared Freshchat user ID as the variable default.

2

Save the request and discover its input IDs

Save apiTool.id as API_TOOL_ID, then inspect the schema and input IDs:

Match each variables[].name to its id; keep those IDs for the attachment below.

3

Execute against a test customer

Check success, error, truncated, output.status and output.body. A successful lookup has HTTP 200 and the expected output.body.id, output.body.first_name and output.body.email. A Voiceflow HTTP 200 alone is not provider success.

Make the lookup available to the agent

Studio

Keep the lookup in Global tools, write a trigger for authenticated customer questions, and run a conversation with your application-provided Freshchat user ID. Confirm that the correct record was used. Publish the tested Environment after preparing its published Secret value.

Code

Save this as freshchat-attachment.json. Replace the tool ID and the input IDs using the returned variables[] values:

Inspect tool and resolve unresolvedReferences before testing. Creating the request does not attach it. Test agent routing in Draft, set the target Published Secret value with versionVariant: "published", then publish the tested agent. Management and standalone execution use Draft; a named Environment’s Draft override does not set its Published value.

Repair authorization or replace a token

Update the credential used by the selected Draft and Published agent.
  • 401: check the account API host and token expiry. Ask the administrator for a valid token, update the Draft Secret, test a read, then update the target Environment’s Published value. Regeneration invalidates the previous account token; coordinate all consumers.
  • 403: confirm the account and operation are permitted. Retrying does not add permission.
  • 429: honor Freshchat’s rate-limit headers before retrying. After an uncertain write, inspect the case rather than creating it again blindly.

Finding customers

Use verified customer identity to retrieve the right Freshchat record.

The lookup configured above reads GET /v2/users/USER_ID. The returned user has a root id, first_name, last_name, email, phone and properties. Freshchat’s user ID differs from your application’s user ID and from a support agent’s ID.

Establish the customer mapping

Studio

  • Ask your application developer to map the signed-in customer to a verified Freshchat user ID. Create freshchat_user_id in More → Variables with an empty default; the developer supplies it in the initial action’s variables before lookup.
  • In Find Freshchat customer, bind user_id to {freshchat_user_id} and api_token to the freshchat_token Secret. Use a known test customer and confirm the returned root id and permitted profile fields.
  • Capture only the context needed for the support task. A customer entering another person’s email must not gain access to that person’s profile or conversations.

Code

Resolve the authenticated customer on your backend. If you need a search, GET /v2/users?email=URL_ENCODED_EMAIL or ?reference_id=URL_ENCODED_REFERENCE returns users[]. At least one supported search criterion is required. Follow the response’s links.next_page.href when present, restricting it to the same trusted account origin, and verify the match against your own identity record. Search results alone are not authentication.

For a missing customer, POST /v2/users with confirmed first_name, last_name, email or phone, then persist the root id from the 201 response. Do not create a new user for every turn. Send the verified provider ID in the next action’s variables before running the attached lookup. Use the earlier API/CLI workflow to test the lookup against that ID.

Update confirmed profile details

Change the customer's name or contact details, then read them back.

Freshchat’s PUT /v2/users/USER_ID updates only email, first_name, last_name and phone. An omitted or null field retains its current value. Do not promise updates to properties or reference_id through this operation even though those fields appear in the broader user schema.

Studio

Create a separate API tool using PUT https://YOUR_ACCOUNT.freshchat.com/v2/users/{user_id} with the token Secret and Content-Type: application/json. Set the raw JSON body to {payload}. Create freshchat_profile_payload in More → Variables with an empty default; your developer serializes only confirmed fields using literal-safe preparation and supplies the resulting string in the next action’s variables. Bind user_id to {freshchat_user_id} and payload to {freshchat_profile_payload}. Test the developer’s prepared input, then GET the user again to verify the change.

Code

Copy the lookup definition, change httpMethod to "put" and add body: {"type":"raw-input","contentType":"json","content":"{payload}"} plus Content-Type: application/json. Use the write-payload encoder and pass the string as standalone inputs.payload. Create an empty freshchat_profile_payload variable using the earlier API or CLI command, populate it with the next action, and attach this tool with its own input IDs and trusted defaults for token, user and payload (required: false). A 202 response means accepted: GET the user again and compare the changed fields before reporting completion.

Creating conversations

Open a support request in the right topic and keep its conversation ID.

Freshchat calls a conversation topic a channel in its API. Ask your administrator to select the intended topic using GET /v2/channels and provide its id; use GET /v2/groups for allowed support-group IDs. Keep those routing choices under application control.

Prepare write payloads

Your backend builds the request from the verified Freshchat user ID and the customer’s confirmed issue. This illustrative payload creates a text conversation; replace both IDs with approved values:

Use actor_type: "user" with that customer’s valid actor_id. A developer must JSON-serialize dynamic text, then escape braces inside JSON strings as \u007b and \u007d before Voiceflow interpolation. Object braces stay intact; Freshchat receives the original decoded strings. This prevents customer text such as {customer_name} from being treated as a variable or Secret reference. Studio authors should obtain the prepared string from their developer.

Code

Save the confirmed body above as freshchat-conversation-payload.json. This encoder can be reused for the profile and note payloads by changing the file name:

Create and test the conversation tool

Studio

1

Add the request

Open Agent → Global tools → + → API and create Create Freshchat conversation. Choose POST https://YOUR_ACCOUNT.freshchat.com/v2/conversations. Add Authorization: Bearer {api_token}, bind api_token to freshchat_token, and add Content-Type: application/json. Set the raw JSON body to {payload}.

2

Bind the confirmed request

Create freshchat_conversation_payload in More → Variables, leaving the default empty. Have your developer supply the prepared string in the next action’s variables before the tool runs. Bind payload to that variable. Test with their prepared sample; never interpolate free text into a quoted JSON string by hand.

Bind the prepared conversation payload as the tool’s default value. Photo:
3

Verify the created case

Run once in a test account. Check HTTP 202 and the returned conversation_id. GET /v2/conversations/CONVERSATION_ID, then open the conversation in Freshchat and confirm its topic and initial message. Have the backend retain the returned ID with the verified customer and your own support-request ID.

Code

Save freshchat-conversation-tool.json, replacing the account host:

Build standalone inputs from the encoded file:

Save apiTool.id as CONVERSATION_TOOL_ID, then execute:

Inspect success, error, output.status and output.body.conversation_id; HTTP 202 is acceptance. GET the case and verify it in Freshchat before reporting it ready. Store the provider ID with the authenticated customer and your own support-request ID; users is not returned by conversation GET, so that response alone cannot prove ownership.

Create an empty freshchat_conversation_payload variable with the earlier API/CLI pattern. Your backend supplies the encoded string with the next action. Discover this tool’s input IDs, then attach it using CONVERSATION_TOOL_ID with defaults api_token: {freshchat_token} and payload: {freshchat_conversation_payload}, both required: false. Keep the create trigger distinct from case lookup, require confirmation, test Draft, prepare the Published Secret and publish the tested agent.

Avoid opening duplicate support requests

Retain the provider ID and reconcile a lost response before retrying creation.

Store one Freshchat conversation ID per application support request. Do not assume POST is idempotent. If creation times out, use GET /v2/users/USER_ID/conversations to inspect that verified customer’s conversations before issuing another create. Compare the topic and initial issue; do not attach a customer to an arbitrary recent case.

Reading and routing conversations

Review a customer’s case and route it to the right support teammate.

Read GET /v2/conversations/CONVERSATION_ID for the stored case. The response includes conversation_id, status, channel_id, assigned_agent_id and assigned_group_id. It does not return the users association supplied at creation: your backend must authorize access against its saved customer-to-case mapping.

Supply a verified case ID

Studio

Create freshchat_conversation_id in More → Variables, leaving its default empty. Ask your developer to populate it in the next action’s variables after verifying the case belongs to this customer. Do not bind it to a number or ID chosen by the model. Add a GET API tool at https://YOUR_ACCOUNT.freshchat.com/v2/conversations/{conversation_id}, binding conversation_id to that variable and api_token to the token Secret. Test with the authorized case and check its status and topic.

Code

Retain conversation_id from creation with the verified Freshchat user and your own support-request ID. For existing cases, establish that association on your backend before returning any data. Create the empty freshchat_conversation_id variable with the earlier API/CLI workflow and populate it in the action before execution. Copy the lookup tool, change its URL to /v2/conversations/{conversation_id}, discover its new input IDs and attach it with defaults api_token: {freshchat_token} and conversation_id: {freshchat_conversation_id}, both required: false.

Read the conversation history

GET /v2/conversations/CONVERSATION_ID/messages?items_per_page=50&page=1 returns messages[]. Follow message pages before declaring a history complete; the maximum page size is 50. from_time=UTC_TIMESTAMP includes messages at that timestamp, so deduplicate by message id when reading incrementally. Keep the current interaction_id: reopening a resolved conversation starts a new interaction within the same conversation.

Studio

Create another GET tool using /v2/conversations/{conversation_id}/messages and those fixed pagination query parameters. Reuse the trusted token/case bindings, then capture only the customer-visible text needed for the task. Have your developer paginate/filter the history when the task needs more than the returned page; private notes must not become customer replies.

Code

Use the same API/CLI tool workflow for the message URL, binding this tool’s own token and case inputs. If your backend aggregates history, paginate it and retain message/interaction IDs. Remove private, system and unsupported content before returning a customer-visible history; do not expose the account-wide raw response directly to the client.

Assign or resolve the case

Use PUT /v2/conversations/CONVERSATION_ID with the change you intend:

  • Assign a group: {"status":"assigned","assigned_group_id":"APPROVED_GROUP_ID"}. Freshchat can return status new after placing it in that group.
  • Assign a teammate: {"status":"assigned","assigned_agent_id":"APPROVED_AGENT_ID"}. If the case has a group, the teammate must belong to it. Obtain allowed IDs from your administrator via /v2/groups and /v2/agents.
  • Resolve: {"status":"resolved"}.
  • Reopen: {"status":"reopened"}. This unassigns the current teammate and starts a new interaction; do not treat later events as part of an ended Voiceflow handoff.

Studio

1

Configure the permitted change

Create a separate PUT API tool for each permitted change. Use {conversation_id} with the verified case variable, Authorization: Bearer {api_token} bound to the Secret and Content-Type: application/json. Put the fixed JSON above in the raw body after your administrator replaces the allowed routing ID.

2

Verify the changed case

Confirm with the customer before resolving an active request. Test the change in the test account, then GET the case again to verify its assignment or status.

Code

Copy the case tool definition, set httpMethod: "put", add Content-Type: application/json and a raw JSON body whose content is the selected fixed JSON above. Create, execute and attach with the API/CLI workflow, using this tool’s own input IDs. Fixed routing values do not require a payload variable; keep them server-controlled. Check the returned status/assignment and GET the case after the change.

Set priority for Freshsales Suite chat accounts

Use conversation properties only where Freshchat's contract supports them.

Freshchat’s API documents properties for chat accounts within Freshsales Suite. For those accounts, PUT the conversation with {"properties":{"priority":"High"}}; supported priority values are Low, Medium, High and Urgent. Custom conversation properties use a cf_ prefix. Read the configured fields through GET /v2/conversations/fields before setting them. Keep the same trusted case/token bindings and verify the returned properties. Do not assume these properties work on a standalone Freshchat account.

Adding internal notes

Give teammates private context without sending it to the customer.

Use POST /v2/conversations/CONVERSATION_ID/messages with message_type: "private" and a valid support agent’s actor_id. The default message type is normal, so omitting private can expose the text to the customer. Have your administrator supply an allowed agent ID; never substitute a customer ID.

Add and verify a private note

Studio

1

Prepare the private note

Have your developer authorize the case using the verified case mapping, build the note with the allowed agent ID and serialize it using literal-safe preparation. Create freshchat_note_payload in More → Variables with an empty default. The developer supplies its prepared string in the next action before the tool runs.

2

Configure and test the request

Create Add Freshchat note under Agent → Global tools → + → API. Use POST https://YOUR_ACCOUNT.freshchat.com/v2/conversations/{conversation_id}/messages, the token Secret, Content-Type: application/json and raw JSON {payload}. Bind conversation_id to {freshchat_conversation_id} and payload to {freshchat_note_payload}. Test the developer’s prepared note, check the root message id and message_type: "private", and confirm it appears privately in Freshchat.

Code

Reuse the conversation write-tool definition and encoder, changing the URL to /v2/conversations/{conversation_id}/messages. Add the authorized case ID to standalone inputs alongside api_token and encoded payload. Create the empty freshchat_note_payload variable with the earlier API/CLI pattern; populate it in the next action. Discover this tool’s own input IDs, then attach with defaults api_token: {freshchat_token}, conversation_id: {freshchat_conversation_id} and payload: {freshchat_note_payload}, each required: false.

Check the provider HTTP 200, root message id and message_type: "private". Read back the messages and confirm the note is private in Freshchat. Your live relay must exclude it from customer callbacks.

Import help articles

Answer from your team’s Freshchat FAQs through Voiceflow Knowledge.

Have your support content owner supply the approved FAQ text, including each question and its current answer. Freshchat’s widget/mobile FAQ display does not create a Voiceflow Knowledge connection. The workflow below imports that supplied text; it does not synchronize a Freshchat account or expose private articles publicly.

Import and verify the answers

Studio

1

Obtain approved content

Ask the Freshchat content owner to provide the current questions and answers as plain text. Remove customer-specific records and internal-only answers that this agent should not disclose. Keep the original source and revision with your content review process.

2

Import the text

In your Voiceflow project, open Knowledge base → Add data source → Plain text. Paste the approved FAQ content and click Import. Wait until processing finishes.

Import the FAQ text approved by your support content owner. Photo:
3

Test actual retrieval

Enable Knowledge base in the agent’s system tools. Ask a question answered by the imported FAQ, then inspect the agent’s retrieved source and answer. A document appearing in Knowledge does not prove the agent used it. Publish the tested Environment when ready.

Code

Save the owner-approved content as a UTF-8 file named freshchat-faq.txt. Use the Voiceflow management bearer token, project and target Environment from connection setup. This is a multipart API upload, not a Freshchat API call:

Save document.id as DOCUMENT_ID, then check processing in the same Environment:

Wait for document.status.type to reach SUCCESS; inspect ERROR before retrying. Enable the agent’s Knowledge tool and test a real question through the Chat agent API, checking the retrieved source and answer before publishing. The import response is not a retrieval test.

Keep FAQ answers current

Replace reviewed content and remove obsolete answers explicitly.

Studio

Keep an owner for FAQ updates. Edit the imported text in Knowledge when the approved source changes, wait for processing, then repeat the retrieval test. Delete obsolete documents from Knowledge; do not leave contradictory copies indexed.

Code

Re-upload the revised file with the same filename and overwrite=true in the text-creation URL to replace it; filenames are unique across the project’s Knowledge base, not just a folder. Poll processing again and test retrieval. To remove the document, use DELETE /v1/stable/document/DOCUMENT_ID?projectID=PROJECT_ID&environmentAlias=ENVIRONMENT with the same management token. There is no automatic Freshchat FAQ refresh in this text-import workflow. See Knowledge document management.

Human agent hand-off

Keep the customer in Voiceflow while your team replies from Freshchat.

A developer must build and host a Custom Handoff relay. The relay creates the Freshchat conversation, forwards customer messages, receives public human replies and sends signed events to Voiceflow. The learning server illustrates the Voiceflow contract; it does not include a Freshchat adapter.

Use this path for text chat. Freshchat file/rich-message APIs do not automatically add file handling to your relay. Disable file uploads until you implement and test them in both directions. A phone transfer uses the separate Voice call transfer workflow.

Prepare the relay and reply delivery

Studio

1

Obtain the deployed service

Ask your developer to implement the Custom Handoff contract and Freshchat text-message delivery. Give them the test account API URL, token, approved topic, support group and the application’s verified customer mapping. They must handle public human replies, resolution, duplicate deliveries and private-message exclusion. Connecting the settings form does not build this service.

2

Obtain the connection values

Have the developer supply the HTTPS Base URL, relay Authorization header value, a separate Webhook secret of at least 32 characters for Voiceflow callbacks, and an application customer identifier the relay can map to the Freshchat user. Share credentials through your team’s secure process. The Freshchat token stays on the relay, separate from these connection credentials.

3

Confirm readiness

The service must accept authenticated create/message/end requests and have a running, authenticated Freshchat reply worker before you connect it. Have the developer confirm the topic/customer mapping and allowed human-agent IDs. The complete two-way test happens after the Workflow and customer client are ready below.

Code

Implement the connection’s create, message and end routes. Persist the Voiceflow connection ID, authenticated application customer, Freshchat user/conversation/topic/current interaction IDs and processed message IDs. Map endUser.externalId against your own customer records; do not trust it without validating the Voiceflow project and application association.

1

Create and retain the Freshchat conversation

On POST /conversations, verify the allowed project and idempotency key. Resolve the customer to the Freshchat user and use the conversation payload to call Freshchat POST /v2/conversations. Save its returned conversation_id before returning your own { "conversationId":"YOUR_CONNECTION_ID" } to Voiceflow. Use the configured topic, not an arbitrary model-selected destination.

Create the initial customer-visible request as normal; post internal escalation context separately as an agent private note using the note contract. Never place private transcript content in the initial public message. Retain the interaction ID from the created/read messages for later delivery filtering.

2

Forward customer text

On POST /conversations/YOUR_CONNECTION_ID/messages, find the stored provider conversation and deduplicate Voiceflow’s message id. Call Freshchat POST /v2/conversations/FRESHCHAT_CONVERSATION_ID/messages with the mapped user ID:

Serialize the real text with a JSON library. Reject unsupported files explicitly; do not acknowledge a message that was dropped.

3

Run an authenticated reply worker

Poll GET /v2/conversations/FRESHCHAT_CONVERSATION_ID/messages with from_time and items_per_page=50, following every page. Start from the saved creation time, retain a durable watermark and deduplicate by message id because from_time is inclusive. Keep a small overlap when resuming so equal timestamps are not lost. Honor account rate-limit headers, back off on 429/transient failures and stop on terminal authorization errors until credentials are repaired.

Forward only actor_type: "agent", message_type: "normal", a non-empty text part and an actor_id in your administrator-approved human allowlist. Reject bot, system, user, private, unknown and missing actors/types; do not infer a person from an outgoing message. Look up the human display name from the approved agent record. Restrict messages to the saved current interaction.

4

Deliver signed callbacks and closure

Translate each approved reply to message.received using the Voiceflow connection ID, stable provider message ID, timestamp, text and human agent name:

Send to https://general-runtime.voiceflow.com/handoff/webhook/custom with the Voiceflow HMAC headers. Retry transient callback failures using the same event ID; retain undelivered events. The shared protocol module implements this signing/retry shape.

Also poll GET /v2/conversations/FRESHCHAT_CONVERSATION_ID. Serialize delivery per conversation. When the active interaction reaches resolved, finish fetching its message pages, persist every pending approved reply and await successful Voiceflow delivery of those replies before sending conversation.ended once. Do not let a separate status poll overtake the last human message; Voiceflow closes the active mapping on the end event. Stop the worker only after closure is accepted. On Voiceflow POST /conversations/YOUR_CONNECTION_ID/end, PUT the provider case with {"status":"resolved"} and mark it ended. Make reflected closure idempotent. A later reopen gets a new interaction; it must not revive an ended Voiceflow connection.

Connect the service and route the agent

Studio

1

Open the connection

Open your project in Agent studio, then Integrations → Custom Handoff → Connect. Enter the developer’s Base URL, Auth header name Authorization, Auth header value and Webhook secret. Select Connect.

Connect the deployed relay using its own credentials. Photo:
2

Configure the support Workflow

Create a Workflow, add a Handoff step and choose Custom Handoff. Set End user ID to {freshchat_user_id} from customer setup. Your backend must populate this empty-default variable with the verified Freshchat user ID before the action that starts handoff; the relay validates its customer/project association. Select Full transcript for Handoff context only when that content may be shared with the team. The relay must place internal context in a private note. Keep file uploads disabled and enable Return and Fail paths.

Route the support Workflow through the Freshchat relay. Photo:
3

Attach and test the Workflow

Add the Workflow to the agent and explain when to call it, such as the customer asking for a person. Publish the test Environment, connect the actual customer chat and complete the checks below with a support teammate. Setting Queue ID routes a Freshchat group only if your relay explicitly maps it.

Code

Once the service and reply worker are ready, save freshchat-handoff.json. These are your relay credentials, not the Freshchat token:

A 200 confirms stored project default-slot configuration, not delivery. Complete the headless Workflow creation, attachment and publication procedure with provider custom, trusted customer identity and Return/Fail paths. Preserve existing agent registrations. Implement the Chat handoff traces and human-message contract in your customer client and test that published Environment.

Verify the complete conversation

  1. Escalate once from the verified test customer. Confirm one Freshchat conversation in the intended topic, with the correct customer and private escalation note.
  2. Send customer text from Voiceflow and a public human reply from Freshchat. Confirm each reaches the other interface once.
  3. Add a private note, a bot message and an unknown actor. None may become a customer reply. Replay a message ID and confirm no duplicate.
  4. Send a final human reply and immediately resolve in Freshchat. Confirm the reply arrives before closure and check the Return path. Separately end from Voiceflow and confirm the provider case resolves once. Reopen the provider case and confirm its new interaction does not revive the ended connection.
  5. Stop the service and check the Fail path for a new handoff. Inspect the worker, stored IDs and signed callback response if a reply is missing.

Use the up and down arrow keys to select a result, Enter to open it, and Escape to close the search.