Free OpenClaw Skill for Shopify Stores: Support and Cart Recovery Agent (Download)

What this skill does for your Shopify stores

• Triages Gorgias / Re:amaze / Zendesk tickets by intent (refund, shipping, sizing, exchange, complaint) and drafts the response.
• Reads abandoned cart events from Shopify Flow and orchestrates Klaviyo or Postscript sequences keyed to product price, customer LTV, and cart contents.
• Sends review requests at the optimal post-delivery window per product category, routes responses through Yotpo, Okendo, or Junip.
• Detects refund risk early from support sentiment, surfaces it to the operator with a one-click win-back offer.
• Logs everything to a single source-of-truth memory so support, retention, and reviews share context across the customer lifecycle.

What's inside this OpenClaw skill

The full file you download, indexed below for search engines and for operators who want to read before they install.

---
name: shopify-support-and-cart-recovery
description: Support triage, abandoned cart recovery, and review request orchestration for Shopify stores. Integrates with Klaviyo, Postscript, Gorgias, Re:amaze, Yotpo, Okendo, Junip, Shopify Flow.
version: 1.0.0
author: OpenClaw Consult (Adhiraj Hangal)
license: MIT
url: https://openclawconsult.com/skills/shopify-stores
---

# OpenClaw Skill: Shopify Support and Cart Recovery

## Overview

This skill turns the OpenClaw agent into the cross-channel orchestration layer
for a Shopify store. It owns customer support triage in Gorgias / Re:amaze /
Zendesk, abandoned cart recovery via Klaviyo or Postscript, and review request
timing through Yotpo, Okendo, or Junip. The single source of truth is the
customer memory shared across all three workflows.

Designed for Shopify Basic, Advanced, and Plus. Some workflows lean on Shopify
Flow and Shopify Functions when Plus is detected. On lower plans, the
workflows fall back to direct API polling.

## What this skill does

1. Triages Gorgias / Re:amaze / Zendesk tickets and drafts replies
2. Detects refund risk early from support sentiment and surfaces it to the operator
3. Reads Shopify Flow abandoned cart events and orchestrates Klaviyo or Postscript sequences keyed to cart contents and customer LTV
4. Sends review requests at category-specific post-delivery windows
5. Bridges support, retention, and reviews around one shared customer memory
6. Logs every customer interaction across channels for the operator's daily standup

## Triggers

```yaml
triggers:
  - type: heartbeat
    schedule: "0 8 * * *"           # Daily 8am
    action: morning_inbox_triage

  - type: heartbeat
    schedule: "0/15 * * * *"        # Every 15 minutes
    action: poll_helpdesk_for_new_tickets

  - type: on_event
    event: shopify.checkout_abandoned
    action: enter_abandoned_cart_sequence

  - type: on_event
    event: shopify.fulfillment_delivered
    action: schedule_review_request

  - type: on_event
    event: helpdesk.ticket_created
    action: triage_and_draft_reply

  - type: on_event
    event: shopify.refund_created
    action: log_refund_to_memory_and_pause_klaviyo_flows
```

## Workflow: support triage

When a new ticket lands in Gorgias / Re:amaze / Zendesk, the agent:

1. Classifies intent: order status, shipping change, sizing, refund, exchange, complaint, wholesale inquiry, PR inquiry
2. Pulls the customer's full history from Shopify (order count, LTV, last contact)
3. Checks for known patterns (same SKU complaint repeating, address-change after fulfillment, etc.)
4. Drafts a reply keyed to intent + customer LTV
5. Routes to the operator for approval (or autonomous send if the intent is on the approved-templates list)
6. Logs sentiment to memory; flags refund risk before the customer asks

The skill defaults to handling order-status, shipping-window, and sizing autonomously. Refunds, chargebacks, complaints, wholesale, PR all route to a human.

## Workflow: abandoned cart recovery

Shopify Flow fires `checkout_abandoned` to OpenClaw. The agent:

1. Inspects cart contents and total value
2. Looks up customer history (returning customer? VIP? recent refund?)
3. Picks the Klaviyo or Postscript sequence to enter based on segmentation rules in the config
4. Schedules the messages: SMS at 30 min if Postscript subscribed, email at 1 hour via Klaviyo, second email at 24 hours, third at 72 hours
5. Pauses any of those sends if the customer opens a support ticket or hits a do-not-disturb signal
6. Reports recovery rate in the weekly digest

The default segmentation: high-LTV abandoners get SMS + email + a personal Slack ping to the operator. New-customer abandoners get email-only. Recent-refund customers get no cart recovery.

## Workflow: review request orchestration

When Shopify fulfillment is marked delivered, the agent waits a category-specific window then requests a review via Yotpo, Okendo, or Junip.

Default windows:

```yaml
review_windows:
  apparel: 7d
  footwear: 14d
  skincare: 21d
  supplements: 28d
  food_beverage: 5d
  electronics: 14d
  furniture: 14d
  big_ticket_over_500: 14d
  default: 10d
```

Editable in the config block. The agent will not request a review from a customer with an open support ticket, or from a customer who issued a refund in the last 30 days.

## Workflow: cross-channel customer memory

The skill maintains a single customer memory shared across support, retention, and reviews. Every channel reads and writes the same memory keys, so:

- A customer asking about sizing in Gorgias gets paused from their abandoned cart Klaviyo flow until the sizing question is resolved
- A customer who refunded last week does not get a review request this week
- A high-LTV customer who tickets in with a complaint gets a personal Slack ping to the operator instead of an auto-reply

## Memory keys

```yaml
memory:
  - key: customer.profile[{customer_id}]
    description: Customer LTV, segment, opt-in status, last contact
    schema: { ltv: number, segment: string, sms_opt_in: bool, email_opt_in: bool, last_contact: datetime }

  - key: customer.support_state[{customer_id}]
    description: Active support thread status
    values: [none, open_low, open_mid, open_high, refund_pending, escalated]

  - key: customer.retention_state[{customer_id}]
    description: Active retention flow context
    schema: { active_flow: string, paused_until: datetime, last_message_sent: datetime }

  - key: customer.review_state[{customer_id}]
    description: Pending and completed review requests
    schema: { last_purchase: datetime, review_requested: bool, review_submitted: bool, review_blocked_reason: string }

  - key: store.daily_metrics
    description: Daily roll-up of tickets, recoveries, reviews
```

## Message templates

```yaml
templates:
  support_order_status:
    body: |
      Hi {customer_first_name},

      Order {order_number} shipped on {ship_date} and is in transit. Latest
      scan: {latest_carrier_scan}. Expected delivery: {expected_delivery}.

      Tracking link: {tracking_url}

      Reach back if you need anything else.

      {brand_name} Support

  support_sizing_repeat_complaint:
    body: |
      Hi {customer_first_name},

      Thanks for the note on the {product_name}. I noticed a few customers
      have flagged similar concerns this week, so we are looking into it on
      the product side. In the meantime, here is what I can offer:

      1. Exchange to a half-size up at no charge
      2. Refund if you prefer not to keep trying

      Just let me know which works for you.

      {brand_name} Support

  abandoned_cart_high_ltv_sms:
    channel: sms
    body: |
      Hey {customer_first_name}, it's {brand_first_name}. Saw {cart_items_short}
      sitting in your cart. Want me to hold it for you, or grab one of these
      open spots before they sell? {cart_link}

  abandoned_cart_email_24h:
    channel: email
    subject: "Your cart is still there"
    body: |
      Hi {customer_first_name},

      You left a few things behind:

      {cart_items_list}

      Quick recap on why these are worth the click:

      {cart_items_value_props}

      {cart_link}

  review_request_apparel:
    channel: yotpo_or_okendo
    subject: "How is your new {product_name} treating you?"
    body: |
      Hi {customer_first_name},

      It has been about a week since your {product_name} landed. Now that you
      have worn it a few times, we would love to hear how it is holding up.

      Even a one-line review helps the next customer make the call.

      {review_link}

      Thanks for being a {brand_name} customer.

  vip_complaint_slack:
    channel: slack
    body: |
      VIP COMPLAINT
      Customer: {customer_first_name} {customer_last_name}
      LTV: {customer_ltv}
      Issue: {ticket_summary}
      Suggested response: {drafted_response}
      Ticket link: {ticket_url}
```

## Required integrations

| Integration              | Purpose                                        | Read | Write |
|--------------------------|------------------------------------------------|------|-------|
| Shopify Admin GraphQL    | Order, customer, fulfillment data              | yes  | optional |
| Shopify Flow             | Event triggers (Plus only)                     | yes  | yes   |
| Klaviyo                  | Email subscriber data + flow control           | yes  | yes   |
| Postscript               | SMS subscriber data + send control             | yes  | yes   |
| Gorgias / Re:amaze / Zendesk | Ticket read + draft reply                 | yes  | optional |
| Yotpo / Okendo / Junip   | Review request orchestration                   | yes  | yes   |
| Slack                    | Operator alerts for VIP and exceptions         | no   | yes   |
| OpenClaw Memory          | Cross-channel customer memory                  | yes  | yes   |
| OpenClaw Heartbeat       | Scheduled triage and review windows            | yes  | yes   |

Write-back to the helpdesk starts disabled. Operator-approves-every-reply is the first two weeks. Flip individual templates to autonomous as they prove out.

## Compliance notes

The skill respects subscriber opt-in status from Klaviyo and Postscript before
sending. All outbound copy includes the unsubscribe footer pulled from your
provider's compliance settings. The skill does not send marketing SMS or email
to customers not opted into that channel. Operators in regulated regions
(EU GDPR, CA CCPA) should review the config block flag for cookie-and-consent
checks before enabling abandoned cart recovery on EU traffic.

## Configuration

```yaml
config:
  brand_name: "Your Brand"
  brand_voice: "warm-direct"          # or "playful", "luxury", "no-nonsense"
  approval_mode: operator_approves_all   # or "autonomous_after_2_weeks"
  ticket_intent_categories: [order_status, shipping, sizing, refund, exchange, complaint, wholesale, pr]
  autonomous_template_allowlist:
    - support_order_status
    - support_sizing_standard
  vip_ltv_threshold: 500
  cart_recovery_segments:
    - segment: high_ltv_returning
      cadence: [sms_30min, email_1h, email_24h, email_72h]
    - segment: new_customer
      cadence: [email_1h, email_24h]
    - segment: recent_refund
      cadence: []
  review_windows:
    apparel: 7d
    footwear: 14d
    skincare: 21d
    supplements: 28d
    food_beverage: 5d
    default: 10d
```

## Quick install

```bash
mkdir -p ~/.claude/skills
mv shopify-stores.md ~/.claude/skills/shopify-support-and-cart-recovery.md
# Edit the config block to match your store
```

Launch OpenClaw and the skill is live. Trigger it manually with `triage support inbox`
or `run cart recovery` or wait for Heartbeat to fire on the configured cadence.

## Want it wired to your stack?

The free SKILL.md is the starting point. If you want this plugged into your
specific Shopify Plus app stack, your brand voice, your escalation rules, and
the operator's daily ritual, OpenClaw Consult ships a fixed-price 14-day build.
https://www.adhirajhangal.com/work

Install in 60 seconds

1. 1

   Drop the file into your OpenClaw skills directory

   Save the downloaded shopify-stores.md as ~/.claude/skills/shopify-support-and-cart-recovery.md (or your project-level .claude/skills/). OpenClaw picks up new skill files on next agent launch.

2. 2

   Wire in your Shopify, Klaviyo, and helpdesk credentials

   Edit the integrations block to add your Shopify Admin GraphQL token, Klaviyo or Postscript API key, and Gorgias or Re:amaze API key. Read access is enough for the support and cart workflows; write access on the helpdesk lets the agent reply directly when you flip it to autonomous.

3. 3

   Start in approval mode, validate, then move to autonomous

   Run for two weeks with the operator approving every outbound reply. The skill defaults route anything that touches a refund, a chargeback, or a complaint to a human. After two weeks of validation, flip the templates that consistently perform to autonomous and the operator gets notified only on exceptions.

Example conversation

Common questions

Related free skills