How to Recover Abandoned Carts with Pipedream, Shopify & HubSpot

pipedream.com > Workflows > New Workflow

Create a new Pipedream workflow

Go to pipedream.com and click 'New Workflow' in the top-right corner of the Workflows dashboard. Give the workflow a name like 'Shopify → HubSpot Abandoned Cart'. You'll land on a blank canvas with a trigger slot at the top and an empty steps area below. Pipedream generates a unique HTTPS endpoint URL the moment you add an HTTP trigger — you'll use this URL in Shopify next.

1. 1Click 'New Workflow' in the top-right of the Workflows dashboard
2. 2Enter a workflow name: 'Shopify → HubSpot Abandoned Cart'
3. 3Click the trigger slot labeled 'Add a trigger'
4. 4Search for 'HTTP / Webhook' and select it
5. 5Set the response type to 'Return a custom response' so Shopify's webhook delivery can receive a 200 OK

Shopify Admin > Settings > Notifications > Webhooks

Register the webhook in Shopify

In your Shopify admin, navigate to Settings > Notifications > Webhooks. Shopify natively supports an 'Abandoned checkouts / Checkout created' webhook event — this fires when a checkout is created but not completed after the customer has entered their email. Paste your Pipedream URL into the URL field, set the format to JSON, and save. Shopify will send a test ping to confirm the endpoint is reachable.

1. 1Open Shopify Admin and go to Settings > Notifications
2. 2Scroll to the bottom and click 'Create webhook'
3. 3Set 'Event' to 'Checkout created'
4. 4Paste your Pipedream webhook URL into the URL field
5. 5Set format to JSON and click 'Save webhook'

Workflow Canvas > + Add Step > Run Node.js code

Validate the incoming Shopify payload

Add a Node.js code step immediately after the trigger to validate the webhook and confirm the checkout is genuinely abandoned. Shopify does not distinguish between an active checkout and an abandoned one in the webhook event name — that determination happens based on whether an order was completed. At this stage, extract the fields you need: customer email, first name, cart total, and the abandoned checkout URL. Log these to confirm the data shape before building downstream logic.

1. 1Click '+ Add Step' below the trigger
2. 2Select 'Run Node.js code'
3. 3Paste the extraction code (see Pro Tip below)
4. 4Click 'Test' to run the step against the Shopify test payload

Workflow Canvas > + Add Step > Delay

Add a delay to confirm abandonment

Shopify's webhook fires the moment a checkout is created, not after a proven abandonment window. Use Pipedream's built-in 'Delay' step to pause execution for 60 minutes. If the customer completes their purchase within that window, you'll want to cancel the enrollment — but Pipedream's standard delay doesn't support cancellation. The workaround: after the delay, query Shopify's Orders API to check whether an order exists for this checkout ID before proceeding.

1. 1Click '+ Add Step' and search for 'Delay'
2. 2Select the Pipedream 'Delay' built-in action
3. 3Set the delay duration to 3600 seconds (60 minutes)
4. 4Click 'Save and continue'

Workflow Canvas > + Add Step > Run Node.js code

Check Shopify Orders API to confirm no purchase

After the delay, add a Node.js code step that queries the Shopify Admin REST API to check whether an order was placed against this checkout token. Use the GET /admin/api/2024-01/orders.json?status=any endpoint and filter by the checkout token from the original payload. If an order exists, set a flag to skip HubSpot enrollment and exit the workflow cleanly using $.flow.exit().

1. 1Click '+ Add Step' and select 'Run Node.js code'
2. 2Connect your Shopify store credentials via the Connected Accounts panel on the right
3. 3Write the Orders API check using the checkout token from step 3's output
4. 4Call $.flow.exit('Order completed — skipping enrollment') if an order is found

Workflow Canvas > + Add Step > HubSpot > Search Contacts

Look up or create the HubSpot contact

Add the HubSpot app step to search for an existing contact by email. In Pipedream's step library, search for 'HubSpot' and choose 'Search Contacts'. Use the email address extracted in Step 3 as the search value. If the contact exists, retrieve their contact ID for the enrollment step. If no contact is found, add a second HubSpot step to create a new contact with the cart data before enrolling them.

1. 1Click '+ Add Step' and search for 'HubSpot'
2. 2Select 'Search Contacts' from the action list
3. 3Connect your HubSpot account via Connected Accounts
4. 4Set the search filter: property = 'email', value = steps.validate_payload.$return_value.email
5. 5Add a conditional Node.js step: if contact not found, run 'Create Contact' HubSpot action before proceeding

Workflow Canvas > + Add Step > HubSpot > Update Contact

Update HubSpot contact properties with cart data

Before enrolling the contact in a sequence, update their HubSpot record with the abandoned cart details. Add a HubSpot 'Update Contact' step. Map the Shopify cart total to a custom HubSpot property (e.g., abandoned_cart_value), the checkout URL to abandoned_checkout_url, and the cart item count to abandoned_cart_item_count. These properties make the sequence emails personalizable with tokens like {{contact.abandoned_cart_value}}.

1. 1Click '+ Add Step' and select HubSpot > Update Contact
2. 2Set Contact ID to the ID returned in Step 6
3. 3Add property: abandoned_cart_value = steps.validate_payload.$return_value.cartTotal
4. 4Add property: abandoned_checkout_url = steps.validate_payload.$return_value.checkoutUrl
5. 5Add property: abandoned_cart_item_count = steps.validate_payload.$return_value.itemCount

Workflow Canvas > + Add Step > Run Node.js code

Enroll the contact in a HubSpot sequence

HubSpot's Sequences API allows programmatic enrollment via a POST to /crm/v3/objects/contacts/{contactId}/associations or via the Engagements API. Pipedream does not have a pre-built 'Enroll in Sequence' action, so you'll write a Node.js code step that calls HubSpot's Sequence Enrollment endpoint directly. You need the sequence ID (find it in HubSpot > Sequences > select your sequence > the ID is in the URL) and the sender's userId to assign email ownership.

1. 1Click '+ Add Step' and select 'Run Node.js code'
2. 2Use the HubSpot connected account's OAuth token via auths.hubspot.oauth_access_token
3. 3POST to https://api.hubapi.com/automation/v4/sequences/enrollments
4. 4Set body: { contactId, sequenceId, senderId } where sequenceId is the numeric ID from the HubSpot Sequences URL
5. 5Log the response status and enrollment ID for debugging

Workflow Canvas > Trigger Step > Response Settings

Return a 200 response to Shopify

Shopify expects a 200 OK response within 5 seconds of delivering a webhook. Because Pipedream's delay step pauses execution for 60 minutes, the initial webhook response must be sent immediately — before the delay. Go back to your HTTP trigger step and confirm 'Return a custom response' is enabled. Add a $.respond() call at the very beginning of your first code step to send the 200 immediately, decoupling the response from the downstream workflow execution.

1. 1Click the HTTP trigger step at the top of the workflow
2. 2Confirm 'Return a custom response' is toggled ON
3. 3In your Step 3 Node.js code, add $.respond({ status: 200, body: 'received' }) as the first line of execution
4. 4Click 'Deploy' to save the workflow

pipedream.com > Workflows > [Your Workflow] > Executions

Test end-to-end with a real abandoned checkout

In Shopify, create a test checkout by adding a product to a cart, entering a real email address at the checkout page, and then closing the tab without completing the purchase. In Pipedream, open the workflow's execution log and watch the event appear. After 60 minutes, confirm the workflow resumes, the Shopify Orders check passes, the HubSpot contact is updated, and the sequence enrollment fires. Check HubSpot for the contact's sequence status.

1. 1Open your Shopify store, add a product to cart, begin checkout, enter a test email, then abandon the tab
2. 2In Pipedream, click the 'Executions' tab on your workflow
3. 3Watch for a new execution row to appear within 30 seconds
4. 4After 60 minutes, confirm the execution resumes and all downstream steps show green checkmarks
5. 5Open HubSpot and verify the contact record has updated cart properties and shows active sequence enrollment

Paste this code into the Node.js validation step (Step 3) and again into the Shopify Orders check step (Step 5). The first function extracts and normalizes cart data from the Shopify webhook. The second queries the Orders API and exits the workflow cleanly if a purchase was completed. Both use Pipedream's $.flow.exit() and the connected Shopify account token available via auths.shopify.

// Step 3: Extract and normalize Shopify abandoned cart data
export default defineComponent({
  async run({ steps, $ }) {

// Step 3: Extract and normalize Shopify abandoned cart data
export default defineComponent({
  async run({ steps, $ }) {
    const body = steps.trigger.event.body;

    // Immediately acknowledge the webhook so Shopify doesn't retry
    await $.respond({ status: 200, body: 'received' });

    const email = (body.email || '').toLowerCase().trim();
    if (!email) {
      await $.flow.exit('No email on checkout — skipping');
    }

    const cartData = {
      checkoutId:    body.id,
      checkoutToken: body.token,
      email,
      firstName:     body.billing_address?.first_name || body.shipping_address?.first_name || '',
      lastName:      body.billing_address?.last_name  || body.shipping_address?.last_name  || '',
      cartTotal:     parseFloat(body.total_price || '0').toFixed(2),
      currency:      body.currency || 'USD',
      checkoutUrl:   body.abandoned_checkout_url,
      itemCount:     (body.line_items || []).length,
      createdAt:     body.created_at,
    };

    console.log('Cart data extracted:', JSON.stringify(cartData, null, 2));
    return cartData;
  },
});

// Step 5: Check Shopify Orders API — skip if purchase completed
export default defineComponent({
  props: {
    shopify: {
      type: 'app',
      app: 'shopify',
    },
  },
  async run({ steps, $ }) {
    const { checkoutToken, email } = steps.validate_payload.$return_value;

    const shop   = this.shopify.$auth.shop_id;
    const token  = this.shopify.$auth.oauth_access_token;
    const url    = `https://${shop}.myshopify.com/admin/api/2024-01/orders.json` +
                   `?checkout_token=${checkoutToken}&status=any&limit=1`;

    const response = await fetch(url, {
      headers: {
        'X-Shopify-Access-Token': token,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok) {
      throw new Error(`Shopify Orders API error: ${response.status} ${await response.text()}`);
    }

    const { orders } = await response.json();

    if (orders && orders.length > 0) {
      console.log(`Order found for checkout token ${checkoutToken} — purchase completed, exiting.`);
      await $.flow.exit('Purchase completed — skipping HubSpot enrollment');
    }

    console.log(`No order found for ${email} — proceeding to HubSpot enrollment.`);
    return { proceed: true, email };
  },
});