Chart libraries, a data warehouse, currency/locale handling, and UI that matches the admin. The stack you used to stand up yourself for every merchant-facing analytics feature can now be handed off to Shopify entirely. Your data lives where merchants already make decisions: the Shopify admin.
Pick a chart library, stand up a DWH to sync merchant data, handle currency and locale yourself, and still end up with a UI that doesn't match the admin.
Map your app's data into the Shopify Analytics schema, query it with ShopifyQL, and render it with the same Web Components as the admin. Your app's data sits right where merchants already make decisions.
(App Events is in early access)
The schema is documented
One element renders a chart
Layer annotations and targets on top
Mark a metafield definition as analytics-queryable and it becomes available as a ShopifyQL dimension, right alongside store data.
campaign_sourceStore which campaign an order came from in a metafield, then break sales down by campaign.
subscription_statusStore a customer's subscription status in a metafield, then group by status.
FROM sales SHOW total_sales GROUP BY order.metafields.my_app.campaign_source TIMESERIES day VISUALIZE total_sales
App Events in Analytics makesthe custom events your app already emits queryable in Shopify Analytics. Three steps.
shopify.app.toml — declare your events in the new registry.
Emit the events via the App Events API.
Merchants can query FROM app_events in ShopifyQL, just like store data.
FROM app_events SHOW emails_sent GROUP BY app_name TIMESERIES day VISUALIZE total_sales
* The above is copied verbatim from the sample in the original post.
a stable, versioned, schema-documented surfaceis what you build against (stable, versioned, schema-documented surface).
Because the schema is public documentation,AI toolchains can generate ShopifyQL that actually runs.
Third-party apps can now embed the same Web Components that render analytics in the Shopify admin.
<s-shopifyql-metric-card><s-metrics-bar><s-metrics-bar-date-picker><s-shopifyql-metric-card heading="My weekly sales" query="FROM sales SHOW total_sales TIMESERIES week VISUALIZE total_sales TYPE bar"> </s-shopifyql-metric-card>
analytics-ui.js must be loadedafter polaris.js. The load order is specified.
Required for the components to run queries.
From there it's just a drop-in.
Two new APIs for layering context on top of the numbers. Usable by apps and merchants alike.
Partner apps can create annotations directly on a merchant's charts via the GraphQL Admin API .
In the chart panel, app attribution renders correctly.
Required scopes
read_analytics_annotations / write_analytics_annotations
Merchants can set targets on any metric and visually track progress inside reports and dashboards.
Targets are a new core primitive in the GraphQL Admin API. Apps can create and read them programmatically, and overlay them on charts.
| What you need to do | Traditional (DIY stack) | Shopify Analytics (this release) |
|---|---|---|
| How data is stored | DIY Stand up a DWH to sync merchant data | Not needed Metafields become analytics-queryable. No ETL, no separate schema |
| App-specific events | DIY Store them on your own infrastructure and surface them yourself | App Events FROM app_events lets merchants query them directly (early access) |
| Query layer | DIY Design your own API | ShopifyQL API Stable, versioned, and schema-documented |
| Chart rendering | DIY Pick a chart library and implement it | Web Components A single element. No library required |
| Currency and locale | DIY Handle it yourself | Not needed Handled by the component |
| UI consistency | Approximate Not perfectly aligned with the admin | Identical Same components as the admin, synced state |
| Adding context to the numbers | Not documented (up to your own implementation) | Annotations / Targets Layering annotations and goals via API |
Just mark a definition as analytics-queryable and it becomes available to ShopifyQL GROUP BY .The essence of this feature is that merchants can slice and view the attributes your app attached, on their own. It has the potential to eliminate an entire ETL pipeline.
The original post explicitly states early access (there is a sign-up link). Declarations go in the new shopify.app.toml registry, and delivery goes through the App Events API.In proposals, separate "features you can commit to today" from "features that require applying".
For Web Components, analytics-ui.js must be loaded after polaris.js , andDirect API access must be enabled before you place the elements. Both the order and the setting are spelled out as requirements, so this is the first thing to check when nothing renders.
The required scope is read_analytics_annotations / write_analytics_annotations.your app's attribution is rendered in the chart panel, so annotations double as a surface for app exposure. Note that adding a scope means re-authorization for existing apps.
The original post splits the intent in two: for developers, "you can build against a stable, versioned, schema-documented surface",for LLMs and agents, "public schema documentation lets AI toolchains generate working ShopifyQL". That makes putting analytics query generation behind an in-app AI feature a realistic design option.
Note that the original post says nothing about available API versions, eligible plans, or pricing for each API. Check the relevant shopify.dev reference before you build.
<s-shopifyql-metric-card> / <s-metrics-bar> . Standardize all queries on the ShopifyQL API.analytics-ui.js must load after polaris.js, with Direct API access enabled. Migration can run card by card in parallel, so you can peel it off incrementally.read_analytics_annotations / write_analytics_annotations is required. Plan on existing apps needing a re-authorization flow when adding the scope.FROM app_events , then use the Metric Targets API to set and overlay targets for quarterly sales or weekly ad-driven sales.