Skip to content

Shopify Dude Fix

ShopifyQL Report Still Works but Has Deprecation Warnings? Read parse Warnings in 2026-10

ShopifyQL now returns non-fatal parseWarnings alongside successful results. Handle GraphQL errors, parseErrors, and warnings separately before report fields break.

Quick answer: If a ShopifyQL report still returns data on Admin API 2026-10, it may also return parseWarnings. Add that field to shopifyqlQuery alongside parseErrors and tableData. Warnings are non-fatal; they can flag deprecated fields before a future API version breaks your dashboard. Do not discard successful results just because a warning exists.
On this page

A successful report is not necessarily a future-proof report

An app dashboard may query Shopify Analytics every morning and render a sales chart without any obvious problem. Older examples often select only tableData and parseErrors. That catches a query that is already invalid, but it misses a query that still works while using a field Shopify plans to remove.

On October 1, 2026, Shopify added parseWarnings to ShopifyqlQueryResponse in Admin API 2026-10. It returns a list of non-fatal messages on successful queries, or an empty list when there are none. This gives app developers a migration signal while the report is still working.

Request results, errors, and warnings together

The following query is suitable for an app that already uses the ShopifyQL GraphQL Admin API. It accepts a ShopifyQL statement as a variable, rather than embedding report logic into the GraphQL query.

query RunReport($statement: String!) {
  shopifyqlQuery(query: $statement) {
    tableData {
      columns { name dataType displayName }
      rows
    }
    parseErrors
    parseWarnings
  }
}
{
  "statement": "FROM sales SHOW total_sales TIMESERIES day SINCE -7d ORDER BY day ASC"
}

Use the 2026-10 API endpoint or later. The app needs the read_reports scope and the applicable protected-customer-data access. Querying parseWarnings against an older schema will itself produce a GraphQL field error; upgrade the endpoint deliberately and test the response shape.

There are three different outcomes to handle

  1. GraphQL error: The request can fail before ShopifyQL executes, for example because of authentication, missing access, or an invalid GraphQL selection. Inspect the top-level errors array and do not try to read report rows from a missing data object.
  2. ShopifyQL parse error: The GraphQL request can return HTTP 200 while shopifyqlQuery.parseErrors explains an invalid report statement. In that case tableData may be null; treat the report as failed.
  3. ShopifyQL parse warning: The statement ran and returned results, but Shopify identified a non-fatal issue. Display or log the warning and schedule a query update. Keep the successful report data available.

A production integration should make these states visible to whoever maintains the report. Do not hide a parse error by returning an empty array; that makes a broken query look like a day with zero sales. Conversely, don’t fail a business dashboard merely because a warning appeared.

Handle the response explicitly

This JavaScript example assumes response is the Fetch response from an authenticated GraphQL Admin request. It separates the three states without pretending that HTTP 200 means the report succeeded.

const payload = await response.json();

if (payload.errors?.length) {
  throw new Error("GraphQL request failed");
}

const report = payload.data?.shopifyqlQuery;
if (!report || report.parseErrors?.length) {
  throw new Error(
    report?.parseErrors?.join("; ") || "Missing ShopifyQL result"
  );
}

if (report.parseWarnings?.length) {
  console.warn("ShopifyQL warnings:", report.parseWarnings);
  // Send warnings to your app's diagnostics, not to a silent catch.
}

const columns = report.tableData?.columns ?? [];
const rows = report.tableData?.rows ?? [];

Do not log customer-level report data to diagnose a parser warning. Capture the saved report identifier, API version, warning text, and a redacted query identifier or approved query text. A warning is a prompt to review the report, not a reason to collect more customer information.

Don’t confuse warnings with reporting freshness

A query can be syntactically valid and still show incomplete recent data while Shopify Analytics processes transactions. parseWarnings is about non-fatal query issues; it is not a data-freshness indicator, a rate-limit signal, or a reconciliation guarantee.

Likewise, a query that returns too much data may fail with a GraphQL RESPONSE_TOO_LARGE error. Retrying the identical request will not fix that. Reduce the date range, number of dimensions, or row limit. Shopify’s ShopifyQL guidance separates those operational errors from parser feedback.

Make warnings part of release testing

If your app has saved ShopifyQL statements for sales, products, campaigns, or custom analytics, run a small suite of representative queries against the target API version before deploying. Treat new warnings as migration tickets with owners, not as noise. That is particularly useful when an app has dozens of merchant-specific reports and a field deprecation may affect only one.

The report output should keep its original query, API version, and diagnostic status together. A dashboard that silently swaps a removed metric for another one can be worse than a report that clearly says it needs maintenance. Update the query intentionally and compare the business meaning of the old and new metrics.

Common misunderstanding: “If parseWarnings is non-empty, the numbers are invalid.” Shopify explicitly returns warnings with successful results. They are reasons to review compatibility, not automatic evidence of bad calculations. parseErrors and top-level GraphQL errors are separate failure paths.

How to test this

  1. On a development app using Admin API 2026-10, run a valid FROM sales query and confirm parseErrors and parseWarnings are arrays.
  2. Deliberately run a malformed ShopifyQL statement and confirm the integration reports a parse error instead of showing zero sales.
  3. Run a request with insufficient permissions in a safe test environment and confirm top-level GraphQL errors are handled separately.
  4. Use a documented or controlled deprecated field if available and confirm a non-fatal warning is captured while the successful report still renders.
  5. Check that warning logs include the report identifier and API version without exposing customer-level rows.
  6. Reduce a large query’s date range or dimensions if the response is too large, rather than retrying the same payload.
  7. Compare a representative report with Shopify admin analytics before and after changing a warned-about field.