Solving the Shopify Pickup Problem: A Community-Driven Guide to Checkout Prefills

Hey fellow store owners! As someone who spends a lot of time digging through the Shopify community forums, I often come across discussions that really hit home for many of you. One recent thread, titled initially as a feature request about respecting cart-level pickup selections at checkout, brought to light a pain point that's surprisingly common and incredibly frustrating for stores offering both shipping and local pickup.

It’s a scenario many of you know well: a customer carefully selects 'local pickup' for their order in the cart, maybe even ticks a confirmation box, only to get to the checkout page and find it’s defaulted back to 'Ship'. Argh! This isn't just annoying; it leads to avoidable ordering mistakes, extra customer service work, and a generally less-than-smooth experience. JohnQQ in the forum perfectly summed it up, noting that while Shopify supports mixed fulfillment, it doesn't preserve that crucial cart-level selection.

The Pickup Predicament: Why Shopify Defaults to Shipping

The core of the issue, as LetThemEatVegan originally posted, is that there’s no native setting on any Shopify plan to automatically carry a cart-level pickup choice through to checkout. This means the checkout process often resets to 'Ship' by default, even if the customer has clearly indicated a preference for 'Pick up'.

This gap is particularly challenging for merchants with a mixed catalog – think a café selling both physical goods to ship and prepared food for local collection. Without a solution, you’re left with customers accidentally choosing shipping for pickup-only items, leading to refunds, re-orders, or manual adjustments. As umerzaman152 pointed out, this is a "real gap" in the system.

Community Brainstorming: Early Workarounds

Before diving into the ultimate fix, the community explored a few workarounds, each with its own pros and cons:

• For Pickup-Only Products: umerzaman152 suggested putting these items in a separate shipping profile/location that only offers local pickup. If a cart contains only these items, the checkout has no shipping options, effectively forcing pickup. This is a clever way to handle specific product types.
• For Mixed Carts (Shopify Plus): If you’re on Shopify Plus, you have more flexibility. You could save the customer’s cart choice as a cart attribute (e.g., delivery_method = pickup). Then, a checkout UI extension could read this attribute and display a banner like “You chose collection, please select Pick up.” While this doesn’t *change* the selection, it helps guide the customer. Delivery customization functions could also reorder or hide options.
• The Fallback (Manual Review): The simplest, but most labor-intensive, workaround is to add a notice in the cart and order confirmation emails, and manually check each order’s delivery method before fulfilling. As FerasHroub pondered, if the pickup selection appeared in order notes, it would at least help flag discrepancies earlier.

The Game-Changer: The Storefront API Solution

The real breakthrough came when Daniel_Jude shared a powerful insight: the Storefront API can actually pass the customer’s delivery choice through to checkout! This isn't a lock, but a prefill – meaning it respects the customer's selection by opening the checkout with 'Pick up' already chosen, while still allowing them to change it if they wish. This is a huge step forward for user experience.

How It Works: The cartBuyerIdentityUpdate Mutation

The key to this solution lies in a GraphQL mutation called cartBuyerIdentityUpdate. This allows you to update the cart’s buyer identity with a delivery preference. Here’s the basic structure Daniel_Jude provided:

mutation {
  cartBuyerIdentityUpdate(
    cartId: "YOUR_CART_ID"
    buyerIdentity: {
      preferences: { delivery: { deliveryMethod: [PICK_UP] } }
    }
  ) {
    cart { id checkoutUrl }
    userErrors { field message }
  }
}

You can even specify a particular pickup location using the pickupHandle field, which takes a location ID. Pretty neat, right?

Real-World Success: LetThemEatVegan's Implementation Journey

The best part? LetThemEatVegan took Daniel_Jude's suggestion and ran with it, successfully implementing it in their store’s theme! They shared some fantastic notes and practical advice for anyone else looking to try this:

1. No Shopify Plus Needed: This solution runs fine on a Basic plan! No special app or access token was required, as the Storefront API lets a theme update the cart without a token. This is huge for smaller businesses.
2. Getting the Cart ID: The cart ID needed for the mutation comes from the token in /cart.js. You just need to add gid://shopify/Cart/ to the front of that token.
3. Include countryCode: LetThemEatVegan found it beneficial to include countryCode along with deliveryMethod and pickupHandle for robust prefilling.
4. When to Send the Mutation: Instead of sending it when a checkbox is ticked, they send it when the customer presses 'Checkout'. This ensures the mutation reflects the *final* cart contents.
5. Clearing Preferences: Smart move! If a customer removes pickup-only items later, they clear the preference so the checkout doesn't open on 'Pick up' for no reason.
6. Graceful Error Handling: They also made sure that if the request to update the cart buyer identity fails for any reason, it doesn't block the sale. Checkout just opens on 'Ship' as usual. This is crucial for a smooth customer experience.

This implementation means that when a cart has café or pickup-only items, pressing Checkout sends that mutation first, and the checkout now opens on 'Pick up' with their location already selected. They tested it extensively, even with mixed carts of food and shipped goods, and it worked every time!

Actionable Steps for Your Store

So, if you’re facing this "pickup predicament," here’s how you can approach implementing this powerful solution:

1. Identify Your Trigger: Decide when you want to send this mutation. The community found that sending it when the 'Checkout' button is pressed is most effective, as it reflects the final cart.
2. Access Your Cart ID: You'll need a developer to grab the cart ID from your /cart.js token and prepend gid://shopify/Cart/ to it.
3. Construct the Mutation: Your developer will use the cartBuyerIdentityUpdate mutation, including deliveryMethod: [PICK_UP], your specific pickupHandle (location ID), and optionally countryCode.
4. Integrate into Your Theme: This GraphQL mutation needs to be integrated into your theme's JavaScript logic, typically tied to the checkout button click event.
5. Add Smart Logic: Implement logic to clear the pickup preference if pickup-eligible items are removed from the cart, and ensure robust error handling so a failed mutation doesn't prevent checkout.
6. Test, Test, Test: Thoroughly test your implementation with various cart scenarios – pickup-only, mixed carts, different devices – just like LetThemEatVegan did.

This solution, while requiring a developer, offers a robust way to significantly improve the local pickup experience on your Shopify store. It addresses a long-standing pain point and shows the power of community collaboration in finding practical solutions. While a native setting would still be ideal for merchants without developer resources, this Storefront API approach gets us incredibly close to the expected behavior. It's a testament to the flexibility of the Shopify platform when you know how to leverage its APIs. Happy selling!