Mastering Dynamic Shopify Queries: Extracting Orders by Relative Dates with Flow & GraphQL

Hey everyone! As a Shopify migration expert and someone who loves digging into what makes store owners tick, I often see recurring questions in the community that really highlight common pain points. A fantastic recent thread, started by our community member ctevan, perfectly illustrates one of these: how do you pull data, specifically draft orders, from a relative timeframe? Think "orders from 7 to 14 days ago" instead of "orders between January 1st and January 8th."

It's a common scenario, right? You might need to follow up on abandoned carts from a specific window, analyze recent sales trends, or trigger automations based on orders that haven't been touched in a week. The challenge ctevan brought up was that most examples for created_at queries use exact timestamps, making relative queries seem tricky. But good news! Our community came through with some stellar solutions.

The Challenge: Relative Dates in Shopify Queries

When you're working with Shopify's powerful data, whether through an app, custom code, or Shopify Flow, querying by specific dates is straightforward. You just plug in your start and end dates. But what if your "start" and "end" dates are constantly shifting, like "two weeks ago" or "yesterday"? Manually updating those timestamps every time is a pain, and frankly, it's not scalable.

ctevan was looking to grab all draft orders from "2 weeks ago, so between 7 and 14 days ago." This isn't just about getting data; it's about automating a dynamic process. Let's dive into the brilliant ways the community tackled this.

Solution 1: Shopify Flow & Liquid for Automated Queries

One of the most powerful tools for store owners looking to automate tasks without deep coding knowledge is Shopify Flow. Flow allows you to automate tasks and workflows across your store, and critically, it can interact with your store's data.

As ecom-4all pointed out in the thread, Flow's "Get data" action, particularly when querying orders or draft orders, takes Liquid in its query field. This is where the magic of relative dates comes in. Liquid, Shopify's templating language, includes a handy date_minus filter.

Using the date_minus Filter

The date_minus filter allows you to subtract a specified duration from a given date (like "now"). It accepts various formats, including human-readable strings like "14 days", a number of seconds, or an ISO 8601 duration.

To get draft orders created between 7 and 14 days ago, you'd construct your query like this:

created_at:>='{{ "now" | date_minus: "14 days" | date: "%Y-%m-%dT%H:%M:%SZ" }}' created_at:<='{{ "now" | date_minus: "7 days" | date: "%Y-%m-%dT%H:%M:%SZ" }}'

Let's break this down:

• "now" | date_minus: "14 days": This takes the current timestamp and subtracts 14 days from it.
• | date: "%Y-%m-%dT%H:%M:%SZ": This formats the resulting timestamp into the ISO 8601 format, which is required for Shopify API queries.
• created_at:>= and created_at:<=: These are standard Shopify query operators for greater than or equal to, and less than or equal to, respectively.

Pro Tip for Debugging: After setting up your Flow, run it once and then check the run log for that specific step. Flow prints the query *after* the Liquid has been resolved. This allows you to confirm that the generated timestamps are exactly 14 and 7 days back, ensuring your query is accurate before you use the results for any critical operations.

This method is incredibly useful for automating tasks like sending follow-up emails for abandoned carts from a specific window, or generating daily reports on recent draft order activity without manual date adjustments.

Solution 2: Deep Dive with Shopify's GraphQL API

For developers building custom applications, integrations, or needing more granular control, Shopify's GraphQL API is the go-to. thestoremechanic provided excellent insights into using GraphQL for this exact scenario.

The GraphQL draftOrders query (or orders for completed orders) accepts a powerful query argument that can handle both relative dates and exact ISO timestamps.

Option A: Relative Date Syntax in GraphQL

Shopify's search syntax is quite intelligent. You can pass relative date strings directly into the query argument:

query { 
  draftOrders(query: "created_at:>=-14d created_at:<=-7d") {
    edges {
      node {
        id
        name
        createdAt
        # ... other fields you need
      }
    }
  }
}

Here, -14d and -7d are shorthand for "14 days ago" and "7 days ago" respectively. This is a remarkably clean and efficient way to query relative timeframes directly within your GraphQL request.

Option B: Calculating ISO Timestamps Programmatically

If you need more precision, or if your application logic requires calculating exact timestamps, you can do this in your code and then inject them into the GraphQL query. Here's a JavaScript example:

const fourteenDaysAgo = new Date(Date.now() - 14 * 24 * 60 * 60 * 1000).toISOString();
const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();

const query = `created_at:>='${fourteenDaysAgo}' created_at:<='${sevenDaysAgo}'`;

// Then use this 'query' variable in your GraphQL request:
// draftOrders(query: "${query}") { ... }

In this example:

• Date.now() gives the current timestamp in milliseconds.
• 14 * 24 * 60 * 60 * 1000 calculates 14 days in milliseconds.
• .toISOString() converts the date object into the required ISO 8601 string format.

This approach gives you maximum flexibility, allowing you to build complex date logic in your application before making the API call.

Why This Matters for Your Shopify Store's Growth

Understanding and implementing dynamic date queries is more than just a technical trick; it's a fundamental aspect of building an efficient, data-driven Shopify store:

• Enhanced Automation: Automate follow-ups, reports, and data synchronization without constant manual adjustments.

• Precise Data Analysis: Accurately track trends, identify patterns, and make informed decisions based on specific, dynamic timeframes.

• Improved Customer Engagement: Target customers with timely messages based on their recent interactions or lack thereof (e.g., abandoned carts from a specific period).

• Scalability: As your store grows, manual data extraction becomes unsustainable. These methods ensure your processes scale with your business.

At Shopping Cart Mover, we understand that data integrity and efficient data management are paramount, especially during a migration. Whether you're moving to Shopify or optimizing your existing setup, knowing how to leverage Shopify's powerful querying capabilities is key to unlocking your store's full potential.

Conclusion

The Shopify community consistently proves to be a goldmine of solutions, and the discussion around relative date queries is a perfect example. Thanks to insights from members like ecom-4all and thestoremechanic, we now have clear, actionable strategies for dynamic data extraction using both Shopify Flow's Liquid filters and the robust GraphQL API.

By implementing these techniques, you can move beyond static data pulls and empower your Shopify store with intelligent, automated data workflows. If you're looking to optimize your Shopify store's integrations or are considering a migration where data accuracy is critical, don't hesitate to reach out to the experts at Shopping Cart Mover. We're here to help you navigate the complexities of e-commerce data with confidence.