What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
To extract a merchant’s Shopify data, use the GraphQL Admin API; for a large export, Shopify documents asynchronous bulk queries that produce downloadable JSONL. To help an AI agent find products, use the appropriate Shopify catalog interface: Storefront Catalog for one merchant or Global Catalog for cross-merchant discovery. These are separate jobs: catalog tools support buyer-facing discovery, not Admin API exports.
A reliable implementation starts by defining which data or actions the agent needs, granting only the access required, and making any write operation wait for human confirmation. Shopify’s documentation, accessed September 29, 2026, describes the API capabilities and operational limits below; verify the API version your app calls because some limits are version-specific.
Choose the right Shopify interface for the job
“How do I export data from Shopify?” and “How can an AI agent help someone shop?” sound related, but they call for different interfaces. The GraphQL Admin API is for reading and writing merchant store data. Shopify names products, orders, customers, inventory, and metafields as examples; the data an app can access is bounded by authorization and API behavior.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →For buyer-facing product discovery, Shopify documents catalog tools through its Unified Commerce Protocol (UCP) interfaces. The scope may be one store or products across merchants. Neither catalog choice should be treated as a substitute for an authorized Admin API export.
#1 Best Overall
| Need | Interface to consider | Scope |
|---|---|---|
| Read or write merchant store data | GraphQL Admin API | Store data available to the authorized app |
| Product discovery for one merchant | UCP Storefront Catalog or the store-specific Storefront MCP endpoint | One store |
| Product discovery across Shopify merchants | UCP Global Catalog | Catalog across Shopify merchants |
| Agent tools in a shopper’s browser | WebMCP, where supported | Storefront and browser-session context |
Shopify’s catalog interfaces require an agent profile; the catalog overview says an API key is not needed for these interfaces. That setup does not replace the authorization required for an app reading merchant data through the Admin API.
Export Shopify data with a GraphQL Admin API bulk query
For a small dataset where a synchronous response is appropriate, use a normal GraphQL query. For a large, connection-based dataset, Shopify documents bulkOperationRunQuery: submit a query, wait for the asynchronous operation to finish, then download its result as JSONL. This reduces the client-side work of requesting pages one by one; it does not remove query limits or guarantee that every operation completes.
Plan the query before submitting it
- Make sure the query includes at least one connection. Bulk queries can select fields under a single top-level field and may include nested connections.
- Shopify documents a maximum of five total connections and a maximum of two levels of nested connections in a bulk query. Keep the selection focused rather than trying to retrieve every related record at once.
- Decide which records and fields the downstream task actually needs. If the job requires unrelated top-level data, plan separate queries rather than assuming one bulk operation can cover it all.
- Confirm the app’s authorization and the API version it calls before relying on any particular access or concurrency behavior.
Run the asynchronous workflow
- Submit: Send a connection-based query through
bulkOperationRunQueryusing the GraphQL Admin API. The exact endpoint, API version, authentication, and access scopes depend on the app and store; configure these from the applicable Shopify API documentation and the app’s authorization. - Check submission errors: Inspect the mutation response and operation status. A request accepted by the API is not the same as a completed export.
- Wait for completion: Poll the operation status or listen for Shopify’s bulk-operation-finished webhook. Use the completion signal to decide when to retrieve the output instead of assuming a fixed run time.
- Download the result: When Shopify provides the result URL, download the JSONL file promptly and process it line by line. Shopify documents that the result URL expires after seven days; retain the file under your own data-handling controls if you need it longer.
- Handle terminal states: Record the operation’s final status and handle failure or missing-result cases explicitly. Do not pass an incomplete or unavailable export downstream as though it were complete.
Limits and API-version concurrency
Shopify’s bulk operations guide says a query must complete within 10 days. It also documents up to five simultaneous bulk query operations per app per shop for API versions 2026-01 and later. Earlier API versions allow one bulk query operation at a time per shop. These are documented limits, not recommended concurrency targets: check the version your app actually calls and design queueing around that version.
Free tools Windows power users keep installed
One-click scans. No signup required.
Bulk operations shift the work from synchronous page-by-page retrieval to an asynchronous job and a file download. That can simplify large exports, but your application still has to track status, handle failures, download the result before its URL expires, parse JSONL, and decide what to do if the data changes between separate jobs.
Make JSONL processing resilient
JSONL stores one JSON value per line, which lets a client process records incrementally rather than loading a potentially large export all at once. A minimal Python reader for a downloaded file is:
import json
with open("shopify-export.jsonl", "r", encoding="utf-8") as source:
for line_number, line in enumerate(source, start=1):
if not line.strip():
continue
try:
record = json.loads(line)
except json.JSONDecodeError as exc:
raise ValueError(f"Invalid JSON on line {line_number}") from exc
# Validate and handle each record for your application.
print(record)This reader deliberately does not assume a particular record schema. Define and validate the fields your job expects before writing records to another system. For repeatable exports, also record which query and API version produced the file, when the job completed, and whether downstream processing finished; those are application-level controls, not Shopify guarantees.
Pick a catalog interface for the agent’s shopping task
Shopify documents search_catalog, lookup_catalog, and get_product as catalog tools. Choose based on the agent’s scope, not just on which endpoint is easiest to call.
Recommended Free Tools
| Choice | When it fits | What to account for |
|---|---|---|
| Storefront Catalog | The agent should discover products from one merchant | Store-specific scope and required agent profile |
| Global Catalog | The agent should discover products across Shopify merchants | Broader catalog scope and required agent profile |
Before selecting one, map the user journey to the available catalog operations: searching, looking up a known item, or retrieving a product’s details. Keep this shopper-facing flow separate from merchant-authorized export code; a catalog result does not grant access to a store’s orders, customer records, inventory, or metafields.
Choose between a server-connected agent and an in-browser agent
A server-connected MCP client calls tools through an agent’s integration rather than relying on the shopper’s browser session. Shopify documents a store-specific Storefront MCP endpoint as well as the UCP catalog interfaces. This is a natural fit when the agent needs a defined server-side tool surface for product discovery.
WebMCP is a distinct option for agents operating in a shopper’s browser. Shopify’s WebMCP documentation says current agent support is limited to Chromium-based browsers. Browser context can matter for storefront interactions, but browser-based tools and a server-connected MCP integration have different deployment and session assumptions. Select the one that matches where the agent runs and what it needs to do; don’t describe either as an Admin API export path.
Design agent tools that are clear and safe
When exposing an app’s own data or actions to an agent, Shopify recommends plain, specific tool names and descriptions, small focused actions, and keeping relevant custom data in Shopify so agents can access it. Shopify’s guidance puts the reason simply: “An agent chooses a tool by reading its description, so describe what the tool does instead of using brand language.”
- Use an action-oriented description: State what the tool reads or changes, what input it needs, and what the result means. Avoid brand slogans or vague names.
- Keep tools narrow: Separate search, lookup, and product retrieval rather than combining unrelated operations into one broad tool.
- Separate read from write: Make it clear which tools only retrieve information and which can change store data.
- Require confirmation for writes: Present the proposed change and ask the user to confirm before the agent submits it.
- Keep access bounded: Request only the authorization needed for the intended store-data workflow, and make clear to users which merchant and records the operation concerns.
Shopify’s UCP CLI and AI Toolkit quickstart presents supported agent-development environments, but setup commands and compatibility can change. Check Shopify’s current quickstart before choosing an installation command or assuming a particular environment is supported.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Or skip the browser setup
ScreenshotNeo is not a Shopify data-export API and cannot replace the Admin API or catalog tools. It is an alternative to try first when the adjacent job is capturing a rendered storefront page as an image or PDF—without setting up browser automation. Its screenshot API accepts a URL in one GET request; cookie and consent banners, newsletter popups, and chat widgets are removed before the shot; bot checks, blank pages, and failed loads are not billed; and it also offers an MCP server for AI agents.
Example cURL request for a rendered storefront screenshot (replace the URL and use your API key):
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo API documentation for request details. It includes 1,000 screenshots a month free with no card; paid plans start at $5 for 3,000. Sign up for ScreenshotNeo free.
Troubleshoot common implementation failures
- The bulk operation does not start: Check the mutation’s reported errors, the app’s authorization, the query’s connection structure, and whether the query stays within the documented connection and nesting limits.
- The job is still running or fails: Track its actual status rather than relying on a guessed duration. Shopify documents a 10-day completion limit; if it fails, review the query scope and operation status before submitting a corrected job.
- You cannot start another bulk query: Check the API version and whether an operation is already running for that app and shop. The documented concurrency allowance differs between versions 2026-01 and later and earlier versions.
- The download URL no longer works: Shopify documents a seven-day expiry for result URLs. Download promptly after completion and store the file if it must remain available.
- Some expected records or fields are absent: Check that the query selected them and that the app is authorized to read them. The Admin API’s access is bounded by authorization and API behavior; a catalog tool is not a way around those boundaries.
- The agent picks the wrong tool: Make descriptions distinguish search from lookup or retrieval, specify the expected inputs, and avoid broad or promotional wording.
- The agent attempts an unsafe change: Separate read and write tools and put an explicit confirmation step before a write reaches the store.
- A browser agent cannot use the storefront tool: Check the WebMCP integration and browser environment; Shopify’s documentation currently describes agent support as limited to Chromium-based browsers.
Performance, reliability, and cost considerations
Shopify documents bulk operations as a way to fetch data asynchronously and reduce the complexity of pagination for large datasets. The trade-off is a job-and-file workflow rather than an immediate result: you need status handling, download and retention logic, and JSONL processing. Do not infer a completion-time guarantee from the fact that Shopify runs the operation asynchronously.
The reviewed Shopify documentation establishes operational limits, not a universal cost or speed figure for a particular export. Check the applicable API and app terms for costs and plan implications, and measure your own job sizes and processing needs rather than assuming a fixed runtime. Keep concurrency within the limit for the version actually in use, and avoid scheduling simultaneous jobs on the assumption that every version supports five.
Frequently Asked Questions
Does Shopify’s Global Catalog provide access to every merchant’s private store data?
No. The catalog interface is for product discovery across merchants; private merchant data access is a separate, authorization-bounded Admin API workflow.
Can an AI agent use MCP and WebMCP interchangeably?
No. MCP is a server-connected tool interface, while WebMCP is intended for agents operating in the shopper’s browser. Their deployment context and browser support differ.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
