Breaking changes
Shopify Sets Shutdown Date for Global Catalog REST API
Shopify will shut down its Global Catalog REST API on November 2, 2026. Engineering teams must migrate to the new Global Catalog MCP to avoid outages.
Published October 21, 2026 4 min read By the Breakwatch team 1 source
On October 9, 2026, Shopify published a final notice for developers regarding a major platform change. The Shopify Dev Docs confirm that the Global Catalog REST API "stops serving traffic on November 2, 2026." Shopify originally deprecated this API in April 2026. When November arrives, any application still making requests to the old endpoints will receive errors. The shutdown covers all requests to the discover.shopifyapps.com base URL. This includes the search endpoint, the lookup endpoints, and all requests against saved catalogs. The news itself is brief. The implications for engineering teams are substantial.
The architectural shift to MCP
The replacement for the deprecated endpoints is Global Catalog MCP. This new interface implements the Universal Commerce Protocol. This is not a simple version bump. It represents a fundamental shift in how applications interact with the Shopify catalog. Teams are no longer calling standard REST endpoints with standard HTTP verbs. They are invoking specific tools through a Model Context Protocol interface.
The new base URL is catalog.shopify.com. The tools provided are search_catalog, lookup_catalog, and get_product. This requires developers to rethink their integration layer entirely. The response shapes will change. The request structures will change. The Universal Commerce Protocol defines new schemas that applications must adopt.
Moving from REST to a tool based protocol changes the abstraction level. REST APIs map cleanly to standard resource routing. Model Context Protocol tools are designed for different interaction models. The search_catalog tool provides filters, pagination, and buyer context across all Shopify merchants. The get_product tool provides full product details with variant selection and availability signals. Engineering teams must map their existing resource requests to these new functional tools.
What teams must check and change
Engineering teams have a short window to update their code. You need to audit your repositories for the deprecated endpoints immediately. Look for GET /global/v2/search, GET /global/v2/p/{upid}, GET /global/v2/p/by-variant/{vid}, and POST /global/v2/lookup. If you find them, you must rewrite those integrations before the November deadline.
First, change the base URL for these operations to https://catalog.shopify.com/api/ucp/mcp.
Second, map your existing calls to the new tools. Search queries move to search_catalog. Single item lookups move to get_product. Bulk lookups move to lookup_catalog. The bulk tool accepts up to 50 identifiers per request.
Third, update your identifiers. The get_product tool requires a specific global identifier format. You must pass identifiers formatted exactly as gid://shopify/p/{upid} or gid://shopify/ProductVariant/{id}.
Fourth, add the required metadata to your requests. Every request must now include a meta.ucp-agent.profile field containing your agent profile URL.
Fifth, if your application queries saved catalogs, you must change how you reference them. You can no longer use a saved catalog endpoint URL directly. You must pass the catalog ID in the request body as catalog.catalog_id.
Authentication remains unchanged. You can continue generating bearer tokens from your Dev Dashboard client credentials. This is the only part of the integration that does not require a rewrite.
Testing the new integration
Migrating to a new protocol requires thorough testing. Shopify provides utilities to help developers verify their new implementations. You can use the Shopify AI Toolkit to test the tools before deploying your migration. You can also use the UCP CLI. Running the command ucp catalog search allows you to validate your queries against the new Universal Commerce Protocol schemas locally.
Your team should write contract tests against the new schemas. The request and response shapes are entirely different from the old REST API. If your application expects the old REST JSON structure, it will fail when parsing the MCP responses. Update your internal types to match the Universal Commerce Protocol catalog request and response schemas.
A generic contract test might look like this:
async function testCatalogSearchContract() {
const response = await fetch("https://catalog.shopify.com/api/ucp/mcp", {
method: "POST",
headers: {
"Authorization": "Bearer YOUR_TOKEN",
"Content-Type": "application/json"
},
body: JSON.stringify({
tool: "search_catalog",
parameters: { query: "shoes" },
"meta.ucp-agent.profile": "https://your-app.com/profile"
})
});
const data = await response.json();
assert(data.schema_version === "ucp_v1");
}This ensures your application correctly formats the tool invocation and handles the expected response schema.
Designing for protocol shifts
Third party APIs change on their own schedule. A deprecation notice is a ticking clock. When the clock runs out, the old endpoints disappear. This Shopify migration highlights the cost of maintaining external dependencies. Moving from REST to a Model Context Protocol is not a simple URL swap. It requires engineering time to understand the new protocol, rewrite the network calls, and update data models.
Applications tightly coupled to the old REST responses will require significant refactoring. Teams should isolate vendor integrations behind internal interfaces. When a vendor deprecates an API, you only need to update the implementation behind your interface. The rest of your application remains untouched.
To survive constant API churn, engineering teams must adopt defensive design patterns. The adapter pattern is essential for third party dependencies. Instead of calling Shopify directly from your product display components, you route the request through an internal abstraction.
interface CatalogClient {
searchProducts(query: string): Promise<ProductList>;
getProductDetails(id: string): Promise<Product>;
}
class ShopifyMcpAdapter implements CatalogClient {
async getProductDetails(id: string): Promise<Product> {
const shopifyId = `gid://shopify/p/${id}`;
// Implementation calling https://catalog.shopify.com/api/ucp/mcp
// using the get_product tool
}
}When the underlying API changes, the CatalogClient interface remains stable. You only rewrite the ShopifyMcpAdapter. This limits the blast radius of a vendor deprecation. It turns a massive refactoring project into a localized update.
Tracking deprecations is a constant challenge for engineering organizations. The April 2026 to November 2026 timeline provided a standard six month window. Teams often miss these windows because vendor changelogs are noisy. Developers focus on shipping new features. Maintenance tasks are pushed to the backlog until a hard deadline forces action.
The deadline approaches
The November 2 deadline is strict. Applications calling the Global Catalog REST API will break on that date. Check your integrations immediately. Breakwatch maps which files in your repos call each vendor API, watches those vendors' changelogs, docs and API specs, and alerts you when a change affects your code.