Skip to content

Shopify Dude Fix

Shopify 2026-10 Order Sync Skips Records? Fix Exclusive Timestamp Filters

GraphQL Admin API 2026-10 changes how created_at:> handles second-precision timestamps. Use inclusive watermarks and ID deduplication to avoid missing orders.

Type: Developer Guide / Fix · Stage: Scale · Topic: Admin GraphQL / Orders / Incremental Sync

On this page

Quick answer

Shopify changed the meaning of an exclusive timestamp lower bound in GraphQL Admin API 2026-10. A filter such as created_at:>'2026-09-15T12:00:02Z' now excludes all records within the 12:00:02 second. If your integration saves the timestamp of the last order it saw and uses > on the next run, it can miss another order created later in that same second. Change the boundary to >=, replay the boundary second, and deduplicate by Shopify ID.

Why an API upgrade can create a quiet data gap

Some Shopify resources store fractional-second timestamps internally, while the API returns createdAt rounded to second precision. Before 2026-10, a search for created_at:>'...12:00:02Z' compared against the start of that second. An order actually created at 12:00:02.500 could match, even though the response displayed 12:00:02Z. In 2026-10, a greater-than search using a whole-second timestamp begins after the entire second. The same order no longer matches.

This is a search-filter behavior change, not proof that Shopify lost an order or that an ERP failed to import it. It applies to apps using > without fractional seconds on timestamp search filters, including created_at on the orders connection. Shopify says >=, <, <=, date-only values, and explicitly fractional-second boundaries are unchanged.

Audit the watermark before changing code

  1. Find every Admin GraphQL query string built from a stored timestamp, including scheduled jobs, queue consumers, reconciliation workers, and bulk exports.
  2. Record whether the cursor tracks creation time or modification time. A created_at filter cannot discover edits to old orders; use the appropriate updated-time query for that job.
  3. Check the actual API version in the request URL. The new exclusive-boundary behavior starts with 2026-10.
  4. Identify the durable deduplication key. Use Shopify’s globally unique resource id, not order number or timestamp alone.
  5. Confirm that a sync drains every pagination page before it advances its durable watermark.

Use an inclusive boundary and deduplicate

This GraphQL example deliberately includes the last processed second:

query OrdersSinceLastSync {
  orders(
    first: 50
    sortKey: CREATED_AT
    query: "created_at:>='2026-09-15T12:00:02Z'"
  ) {
    nodes {
      id
      createdAt
      name
    }
    pageInfo {
      hasNextPage
      endCursor
    }
  }
}

Replace the example timestamp with your saved checkpoint. Process every page, upsert orders idempotently by id, and only then commit the new checkpoint. If your target system does not have native upsert support, maintain a table keyed by the Shopify order GID or an equivalent stable mapping.

// Illustrative worker logic, not a Shopify SDK method:
const lowerBound = lastCompletedWatermark; // inclusive
for await (const order of paginateOrders({ since: lowerBound })) {
  await upsertByShopifyId(order.id, order);
}
// Commit only after all pages and writes succeed.
await saveCompletedWatermark(maxObservedCreatedAt);

The loop intentionally reprocesses records at the boundary. That’s preferable to silently skipping them. For high-volume stores, retain a small overlap window as an additional operational safeguard, and log processed IDs and page cursors. A durable checkpoint should represent completed processing, not merely the last record fetched.

Do not repair this by adding one second

Advancing a checkpoint from 12:00:02 to 12:00:03 avoids duplicates by discarding everything else in the original second. That is exactly the wrong tradeoff for a sync. Using >= without deduplication is also incomplete: it can create duplicate downstream records or repeated notifications. The two changes belong together.

Common misunderstanding

“The API still returns HTTP 200, so the sync is healthy.” A valid filter can return an incomplete result set for your watermark strategy. “Pagination will catch the missing order.” Pagination only traverses records that satisfy the search predicate. “The fix is to request millisecond timestamps.” Shopify’s documented fix for second-precision response timestamps is an inclusive boundary plus ID deduplication.

How to test this

  1. On a test store, create or identify two orders whose displayed createdAt values fall in the same second, and another in the following second. Capture their IDs.
  2. On API 2026-10, query with created_at:>'T' where T is that shared second; confirm the same-second orders are excluded.
  3. Change the predicate to >=. Confirm the boundary records return and downstream upserts do not duplicate them.
  4. Force pagination with a small first value. Simulate a crash after one page, restart, and verify no IDs are lost.
  5. Run a reconciliation against an overlapping date range, including the moment of the API upgrade, before declaring the integration fixed.

Sources and further reading

Documentation checked October 22, 2026.