How to set up custom actions for claims status routing

• Have a working Chatref agent trained on your practice’s claims policies, FAQs, and insurance details. If you’re still setting up your industry-specific agent, start with the Health Insurance Providers guide.
• Enable the shared inbox – it’s where team members pick up chats the agent can’t resolve.
• Map your claims-status routing logic on paper: what information you need (member ID, claim number, date of service, reason for inquiry), what statuses trigger an automatic answer vs. a human handoff, and which team handles which outcome.
• Gather the URL or endpoint of the internal tool or ticketing system the custom action will call (even if it’s a simple email-to-case gateway).

1. Create the custom action

Go to your agent’s Actions tab and add a new action named “Claims Status Lookup.” Give it a description the agent can use to decide when to trigger it – something like “Activates when a member asks about the status of a claim.”

Add the fields the member will be asked for. At minimum, include:

• Member ID (or subscriber ID)
• Claim number
• Date of service (or the date range)
• A short free-text reason field so the member can explain the query (optional but helps with handoff context)

Set each field as required if you can’t proceed without it.

2. Connect the action to your claims system

Under the action’s Webhook section, enter the endpoint that accepts a POST request from Chatref. The payload will contain the fields you defined plus the conversation’s session ID. Your backend – a small middleware script, a Zapier flow, or a direct integration with your claims portal – needs to:

• Accept the webhook.
• Look up the claim status using the member ID and claim number.
• Return a JSON response with the status (e.g., “approved,” “denied,” “pending”), any relevant details, and a routing instruction – typically a short text summary the agent will show the member, plus a flag like "handoff": true if a human should take over.

If you don’t have a live system ready, you can prototype by returning a static JSON from a service like Postman’s mock server or a simple cloud function. The important thing is that the agent gets a structured response it can interpret.

3. Define the routing rules

Now create the logic that decides what happens after the lookup.

Open the agent’s Routing settings and add a rule set for the claims status action. For each possible status you expect, define:

• When the status is “approved” or “processed”: the agent replies with the details (e.g., “Your claim was approved on [date] for [amount]”). No handoff needed.
• When the status is “denied” or “requires documentation”: the agent informs the member and, if further action is needed, triggers a handoff to the shared inbox. Include the claim number and the status reason in the message handed to the team.
• When the status is “pending” or the backend returns an error: hand off automatically so a staff member can investigate.

You can set these rules using Chatref’s visual flow builder (if available) or through simple “if response contains X, then do Y” logic. The goal is to keep only truly ambiguous or sensitive cases in front of a person.

4. Link the action to the agent’s thread strategy

Back in the main agent settings, make sure the custom action is set to auto-trigger when the agent detects a claims-status question. You can also add a trigger phrase (like “I want to check my claim”) that explicitly starts the action, which is helpful for members who know what they want.

Also confirm that the shared inbox escalation path is active for this action: when the action flags a handoff, the chat should appear in the “Unassigned” queue with the “claims-status” tag and the full lookup result attached.

Test end-to-end as a member:

• Open your site’s chat widget or the preview in the Chatref app.
• Ask “Can you tell me the status of my claim?” or use the dedicated trigger phrase.
• The agent should ask for your member ID, claim number, and other fields.
• After you submit, the agent should either give the status directly or, if you designed a handoff scenario, place the conversation in the shared inbox with all collected details.

Look at the shared inbox yourself. Confirm that:

• The chat shows the collected fields.
• The routing tag is correct.
• The team can reply and see the previous messages.
• The member gets a notification or sees the message when they return.

Run the test with each status outcome you defined – approved, denied, pending, and an error condition – to be sure the handoff rules fire correctly every time.

The action never triggers. Check that you’ve associated the action with the right agent and that the agent’s knowledge base includes enough claims-language content to recognize the intent. If the agent is still learning, add a few sample training phrases and retest.

The member gets stuck in a loop. If the action asks for a claim number but the member doesn’t have it, the agent may keep prompting. Add an exit path: after two failed attempts, route the chat to the shared inbox with a note that the ID wasn’t supplied.

The webhook returns a timeout or empty response. Confirm your endpoint responds within 5 seconds with a valid JSON. If your claims system is slow, use an asynchronous pattern: the action returns an immediate acknowledgment, and you push the result back to the conversation via the Chatref API when ready (if your plan supports it). Otherwise, default to handoff with a “we’re checking” message.

Shared inbox doesn’t receive the handoff. Verify that the shared inbox integration is enabled and that the agent isn’t configured to close the conversation after the action. Also check that no other routing rule is intercepting the thread before it escalates.

Collected data arrives incomplete. If a field isn’t marked as required, members may skip it. Set field-level validation in the action definition and, for claim numbers, add a format hint (e.g., “starts with ‘C-’ followed by 8 digits”) so the agent can reject obviously wrong entries.

What causes claims status routing problems for Health Insurance Providers?

Routing breaks when the agent doesn’t collect a unique identifier (like member ID or claim number) or when the backend can’t parse it into a clear status. Other pain points: the action isn’t trained on enough claims scenarios, the webhook connection is unreliable, or there’s no fallback handoff rule for ambiguous responses. In a shared inbox, missing tags or context can cause a support loop, where agents re-ask for information the action already gathered.

How do I improve claims status routing for Health Insurance Providers?

Start by making sure your agent’s knowledge base covers your full claims terminology and common member phrasing. Tighten your custom action’s field validation so you always collect a valid member ID and claim number. Use clear routing buckets in Chatref – approved, denied, pending – and map every one either to an automatic message or a handoff with full context. Test each path with real member-like queries and monitor the shared inbox regularly; if a single routing error recurs, add a new rule immediately.�