Support context for retailers

Open the chat with the order status

A shopper has reloaded the tracking page for one order four times in ten minutes, and now they open chat. The bot's usual opener asks how it can help, and the shopper types out what the tracking page showed them, then waits while the bot looks the order up. The refreshing was the question. The chat can open with the answer and the order number in it.

What Signals knows

tracking_views_session: Times the order tracking page was opened this visit
last_tracking_url_session: The tracking page they opened last, which carries the order number

What your support desk does

Opens the chat with the status of that order and the carrier's latest scan when the shopper has reloaded the tracking page three or more times this visit. The order number comes from the page they were on and the status comes from your order system.

support.ts · 15 lines

from snowplow_signals import (
    Attribute, AtomicProperty, Criteria, Criterion, Event, StreamAttributeGroup, domain_sessionid,
)

page_view = Event(name="page_view", vendor="com.snowplowanalytics.snowplow", version="1-0-0")
on_tracking = Criteria(all=[
    Criterion.like(AtomicProperty(name="page_url"), "%/orders/%/track%"),
])

tracking_views_session = Attribute(
    name="tracking_views_session",
    type="int32",
    events=[page_view],
    aggregation="counter",
    criteria=on_tracking,
    default_value=0,
)

last_tracking_url_session = Attribute(
    name="last_tracking_url_session",
    type="string",
    events=[page_view],
    aggregation="last",
    property=AtomicProperty(name="page_url"),
    criteria=on_tracking,
)

# Keyed on the visit, so the chat widget asks about this session the moment it opens.
shop_support_tracking = StreamAttributeGroup(
    name="shop_support_tracking",
    version=1,
    attribute_key=domain_sessionid,
    owner="you@example.com",
    attributes=[tracking_views_session, last_tracking_url_session],
)

// In the handler that runs when the chat widget opens
const shopper = await signals.getServiceAttributes({
  name: "shop_support_tracking",
  attribute_key: "domain_sessionid",
  identifier: sessionId,
});
// { tracking_views_session: 4, last_tracking_url_session: "https://shop.example/orders/48213/track" }

if (shopper.tracking_views_session >= 3) {
  const orderId = orderIdFromUrl(shopper.last_tracking_url_session);
  bot.open({
    intent: "order_status",
    order: await orders.get(orderId),
  });
}

Show the agent the error before the shopper describes it

A shopper reached the payment step, the card was declined, and a minute later they are in chat. The agent sees a new conversation with no context, so the first exchange is a request for a screenshot and a description of what the shopper clicked. The error code and the step it happened on were recorded when it happened. They can be on the ticket before the agent says hello.

What Signals knows

last_checkout_error: The error code from the most recent checkout failure this visit
checkout_errors_session: Checkout failures this visit
minutes_since_error: Minutes since the last checkout failure

What your support desk does

Attaches the error code, the checkout step and how long ago it happened to the conversation before the agent opens it, and pulls up the macro your team keeps for that code. The agent decides what to say.

support.ts · 15 lines

from snowplow_signals import (
    Attribute, Event, EventProperty, StreamAttributeGroup, domain_sessionid,
)

checkout_error = Event(name="checkout_error", vendor="com.example", version="1-0-0")

last_checkout_error = Attribute(
    name="last_checkout_error",
    type="string",
    events=[checkout_error],
    aggregation="last",
    property=EventProperty(vendor="com.example", name="checkout_error", major_version=1, path="code"),
)

checkout_errors_session = Attribute(
    name="checkout_errors_session",
    type="int32",
    events=[checkout_error],
    aggregation="counter",
    default_value=0,
)

minutes_since_error = Attribute(
    name="minutes_since_error",
    type="double",
    events=[checkout_error],
    aggregation="time_since_last",
    time_unit="min",
)

shop_support_checkout = StreamAttributeGroup(
    name="shop_support_checkout",
    version=1,
    attribute_key=domain_sessionid,
    owner="you@example.com",
    attributes=[last_checkout_error, checkout_errors_session, minutes_since_error],
)

// In the handler that creates the ticket when a chat starts
const shopper = await signals.getServiceAttributes({
  name: "shop_support_checkout",
  attribute_key: "domain_sessionid",
  identifier: sessionId,
});
// { last_checkout_error: "card_declined", checkout_errors_session: 1, minutes_since_error: 1.3 }

if (shopper.checkout_errors_session > 0) {
  desk.annotate({
    ticket,
    note: `Checkout failed with ${shopper.last_checkout_error}, ${Math.round(shopper.minutes_since_error)} min ago`,
    macro: macros.forError(shopper.last_checkout_error),
  });
}

Start the return instead of asking what the question is

A shopper searched for returns, opened the policy page, read it and then opened chat. The bot's opening question asks what they need, and the shopper explains that they want to return something, which the last two pages said. A chat that opens on the return flow, with the recent orders listed, saves that exchange and the one after it.

What Signals knows

returns_pages_session: Returns and refund pages opened this visit
return_searches_session: Searches this visit that mention returns

What your support desk does

Opens the chat on the return flow, with the shopper's recent orders listed, when they have read a returns page or searched for returns this visit. The order list comes from your order system.

support.ts · 14 lines

from snowplow_signals import (
    Attribute, AtomicProperty, Criteria, Criterion, Event, EventProperty, StreamAttributeGroup, domain_sessionid,
)

page_view = Event(name="page_view", vendor="com.snowplowanalytics.snowplow", version="1-0-0")
search = Event(name="search", vendor="com.example", version="1-0-0")

returns_pages_session = Attribute(
    name="returns_pages_session",
    type="int32",
    events=[page_view],
    aggregation="counter",
    criteria=Criteria(any=[
        Criterion.like(AtomicProperty(name="page_url"), "%/help/returns%"),
        Criterion.like(AtomicProperty(name="page_url"), "%/help/refunds%"),
    ]),
    default_value=0,
)

return_searches_session = Attribute(
    name="return_searches_session",
    type="int32",
    events=[search],
    aggregation="counter",
    criteria=Criteria(all=[
        Criterion.like(EventProperty(vendor="com.example", name="search", major_version=1, path="query"), "%return%"),
    ]),
    default_value=0,
)

shop_support_returns = StreamAttributeGroup(
    name="shop_support_returns",
    version=1,
    attribute_key=domain_sessionid,
    owner="you@example.com",
    attributes=[returns_pages_session, return_searches_session],
)

// In the handler that runs when the chat widget opens
const shopper = await signals.getServiceAttributes({
  name: "shop_support_returns",
  attribute_key: "domain_sessionid",
  identifier: sessionId,
});
// { returns_pages_session: 2, return_searches_session: 1 }

if (shopper.returns_pages_session > 0 || shopper.return_searches_session > 0) {
  bot.open({
    flow: "start_return",
    orders: await orders.recentForSession(sessionId),
  });
}

Route a repeat contact to a person who can see the history

A logged-in customer opens chat for the third time this month, and the first two were about the same order. The bot greets them as a new conversation and starts the same script, and the agent who eventually picks it up reads the earlier threads while the customer waits. The third contact about one order is the moment for a person, with both earlier conversations open before they say hello.

What Signals knows

support_contacts_30d: Support conversations in the last 30 days
contact_orders_30d: The orders those conversations were about
last_contact_topic_30d: What the most recent conversation was about

What your support desk does

Skips the bot and routes to a person when a customer has contacted support twice in the last 30 days about the same order, and opens the earlier conversations beside the new one. Your routing rules pick the queue.

support.ts · 15 lines

from datetime import timedelta
from snowplow_signals import Attribute, Event, EventProperty, StreamAttributeGroup, user_id

support_contact = Event(name="support_contact", vendor="com.example", version="1-0-0")

support_contacts_30d = Attribute(
    name="support_contacts_30d",
    type="int32",
    events=[support_contact],
    aggregation="counter",
    period=timedelta(days=30),
    default_value=0,
)

contact_orders_30d = Attribute(
    name="contact_orders_30d",
    type="string_list",
    events=[support_contact],
    aggregation="unique_list",
    property=EventProperty(vendor="com.example", name="support_contact", major_version=1, path="order_id"),
    period=timedelta(days=30),
)

last_contact_topic_30d = Attribute(
    name="last_contact_topic_30d",
    type="string",
    events=[support_contact],
    aggregation="last",
    property=EventProperty(vendor="com.example", name="support_contact", major_version=1, path="topic"),
    period=timedelta(days=30),
)

# The help desk sends support_contact from the server when a conversation closes, so the user id is the key.
shop_support_repeat = StreamAttributeGroup(
    name="shop_support_repeat",
    version=1,
    attribute_key=user_id,
    owner="you@example.com",
    attributes=[support_contacts_30d, contact_orders_30d, last_contact_topic_30d],
)

// In the handler that routes a new chat from a logged-in customer
const customer = await signals.getServiceAttributes({
  name: "shop_support_repeat",
  attribute_key: "user_id",
  identifier: userId,
});
// { support_contacts_30d: 2, contact_orders_30d: ["48213"], last_contact_topic_30d: "missing_item" }

if (customer.support_contacts_30d >= 2 && customer.contact_orders_30d.length === 1) {
  desk.route({
    to: "agent",
    skipBot: true,
    context: await desk.conversations({ userId, order: customer.contact_orders_30d[0] }),
  });
}

Support that knows what the shopper was doing.

Cut handle time by starting the reply from what the shopper did before asking.

Open the chat with the order status

Show the agent the error before the shopper describes it

Start the return instead of asking what the question is

Route a repeat contact to a person who can see the history

Try it on your own site.