How to Implement UCP 2026: Complete /.well-known/ucp Guide

What Is the Universal Commerce Protocol?

Universal Commerce Protocol is an open-source standard that enables AI shopping agents to interact with merchant systems through a common language. Unlike traditional e-commerce integrations that require bespoke connections for every platform, UCP provides a unified abstraction layer for discovery, capability negotiation, and transaction execution.

The Core Problem UCP Solves

Before UCP, every AI platform (ChatGPT, Claude, Gemini, Perplexity) required unique integrations with each merchant. A store selling on 10 AI platforms would need 10 separate integrations, creating an N x N bottleneck that made agentic commerce economically unfeasible for most businesses. UCP collapses this complexity into a single, standardized interface.

How UCP Works: The Three-Step Flow

UCP operates through a discovery-negotiation-transaction model:

Discovery occurs when an AI agent reads your `/.well-known/ucp` manifest file, a publicly accessible JSON document that declares your store’s capabilities, supported payment methods, and API endpoints. This manifest acts as a machine-readable business card, allowing agents to understand what your store can do without human intervention.

Capability Negotiation follows discovery. The AI agent examines your manifest to determine which features you support (loyalty programs, specific shipping zones, discount codes, subscription models). The agent then negotiates transaction terms based on user intent and your declared capabilities.

Transaction Flow completes the cycle. Once terms are agreed upon, the agent creates a secure checkout session, applies relevant taxes and shipping calculations, and processes payment using tokenized credentials via the Agent Payments Protocol (AP2). The entire flow happens programmatically, without the user ever visiting your website.

UCP vs ACP: Strategic Differences

The Agentic Commerce Protocol (ACP), developed by OpenAI and Stripe, focuses on chat-to-buy interactions within conversational AI assistants. ACP is faster to implement for Stripe-integrated merchants and emphasizes embedded commerce within AI chat interfaces.

UCP, by contrast, targets search-to-buy experiences across Google’s ecosystem and the broader open web. It supports more complex commerce workflows, including post-purchase order management and identity linking via OAuth 2.0. UCP is designed for long-term interoperability and flexibility, while ACP prioritizes rapid deployment for conversational commerce.

Strategic consensus among e-commerce leaders is clear: implement both protocols. Consumers will expect seamless purchasing whether they discover products through ChatGPT or Google AI Mode. Dual implementation ensures maximum visibility across AI-driven shopping surfaces.

Understanding the /.well-known/ Directory

The `/.well-known/` directory is a standardized location on web servers for hosting site-wide metadata related to various web protocols. Defined by RFC 8615, this directory provides a predictable path for automated systems to discover service configurations without requiring manual lookup or documentation.

Why /.well-known/ Matters for UCP

AI agents operate at scale, querying thousands of merchant sites per second. The `/.well-known/` convention eliminates ambiguity: agents know exactly where to find your UCP manifest without parsing HTML, following redirects, or consulting external registries. This predictability is essential for the sub-second response times required by agentic commerce.

Common /.well-known/ Use Cases

Beyond UCP, the `/.well-known/` directory hosts configurations for security certificates (ACME protocol), payment request APIs, and change-password endpoints. For UCP specifically, your manifest must be accessible at `https://yourdomain.com/.well-known/ucp` with proper CORS headers to allow cross-origin requests from AI platforms.

Technical Requirements for UCP Implementation

Implementing UCP requires infrastructure capable of handling real-time API requests, secure payment token management, and dynamic inventory synchronization. The following sections detail the exact technical specifications.

Core Capabilities: The UCP Foundation

UCP defines three mandatory capabilities for basic implementation:

Checkout Capability manages session creation, cart updates, tax calculation, and payment token injection. Your checkout endpoint must accept secure payment tokens from agent-managed wallets, working alongside AP2 to ensure merchants never handle raw financial credentials. The checkout flow must support atomic, non-visual API calls, meaning transactions complete without rendering a traditional checkout page.

Identity Linking Capability enables platforms to obtain user authorization via OAuth 2.0, allowing AI agents to perform actions on behalf of authenticated users. This capability is critical for account-linked checkouts, personalized pricing, and loyalty program integration.

Order Management Capability provides webhook-based updates for order lifecycle events (shipped, delivered, returned, refunded). AI agents subscribe to these webhooks to keep users informed of order status without requiring manual tracking number lookups.

The UCP Manifest File: Structure and Schema

Your UCP manifest is a JSON document that declares your store’s capabilities, endpoints, and payment configurations. A minimal manifest includes:

The UCP version number, ensuring agents know which protocol features your implementation supports. As of January 2026, the current version is 1.0.

Service endpoints define where AI agents should send requests for each capability. For example, your checkout endpoint might be `https://api.yourdomain.com/ucp/checkout`, while order management webhooks point to `https://api.yourdomain.com/ucp/orders/webhook`.

Capability declarations list which UCP features you support. A basic implementation might declare only `product.discovery` and `cart.checkout`, while advanced setups include `loyalty.points`, `subscription.manage`, and `returns.initiate`.

Payment handlers specify accepted payment methods (Google Pay, PayPal, Stripe) and the corresponding token formats. This section must align with your payment processor’s tokenization standards to ensure secure, PCI-compliant transactions.

Public keys for signature verification allow agents to validate that webhook events and API responses genuinely originate from your server, preventing man-in-the-middle attacks and ensuring data integrity.

Infrastructure Readiness Checklist

Before deploying UCP, audit your current infrastructure against these requirements:

Inventory System Synchronization: Your inventory must support real-time updates with sub-second latency. AI agents will query stock levels before completing purchases. Stale inventory data leads to overselling, which damages agent trust scores and reduces future recommendation frequency.

Checkout Logic Atomicity: Traditional checkouts rely on multi-step user flows with visual confirmation. UCP checkouts must be completed in a single API call, including tax calculation, shipping selection, discount application, and payment processing. This requires refactoring checkout logic to operate headlessly.

API Response Times: Target sub-200ms response times for product discovery and sub-500ms for checkout completion. AI agents penalize slow endpoints by deprioritizing your store in recommendation algorithms.

Rate Limiting Strategy: Implement intelligent rate limiting that distinguishes between legitimate agent traffic and potential abuse. Use token bucket algorithms with burst allowances for high-traffic periods.

Implementing UCP on Shopify

Shopify’s native UCP support makes it the fastest path to agentic commerce readiness. As a co-developer of the protocol, Shopify provides first-class integration tools for both standard stores and headless architectures.

Native App Integration for Shopify Standard and Plus

For most Shopify merchants, UCP deployment begins with the official Universal Commerce Agent app from the Shopify App Store. Installation takes under 10 minutes and requires minimal technical configuration.

After installing the app, configure your Agent Policy to define what permissions AI agents have. Start with Read-Only access to test agent behavior without risking unintended transactions. Once validated, upgrade to the Create Carts permission to enable full purchase flows.

Metafield Mapping is critical for accurate product representation. AI agents filter products based on structured attributes (Size, Color, Material). If your product data uses custom metafields, map them to standard UCP fields within the app settings. For example, map your custom `fabric_type` metafield to the standard `Material` attribute so agents can correctly filter “100% organic cotton” products.

Agentic Storefronts are automatically enabled for eligible Shopify stores. Check `Settings` → `Apps and Sales Channels` in your Shopify admin to verify activation. Orders from AI channels appear with a distinct source tag, allowing you to track conversion rates and average order values from agentic traffic separately from traditional web traffic.

Headless Adapter for Enterprise Shopify

High-volume brands running headless Shopify (Hydrogen, custom React frontends) require a UCP middleware layer to achieve the performance and customization needed for enterprise-scale agentic commerce.

Deploy a UCP middleware service alongside your headless storefront. This middleware caches UCP responses at the edge using Cloudflare Workers or Fastly, ensuring sub-200ms response times even during traffic spikes. Without edge caching, direct API calls to Shopify can exceed 500ms during peak periods, causing AI agents to downrank your store.

Data Caching Strategy is essential to avoid rate limiting. Use Shopify’s Bulk Operations API to sync product data to an external database (Redis for session data, Postgres for product catalog). Serve the UCP feed from this cached layer instead of querying Shopify’s APIs for every agent request. Implement webhooks (e.g., `inventory_levels/update`) to immediately invalidate cache when stock levels change, preventing agents from selling out-of-stock products.

Explicit Currency Definition prevents AI hallucinations. Always set the `priceCurrency` field in every `Offer` object within your manifest. Without explicit currency declarations, agents may incorrectly convert prices or display wrong currency symbols, leading to transaction failures and user frustration.

Shopify UCP Performance Monitoring

Track the Agent API sales channel in Shopify Analytics to measure UCP impact. Key metrics include:

Conversion Rate from AI Discovery: Benchmark against traditional web traffic. Early 2026 data shows UCP-enabled stores averaging 28% higher conversion from AI-driven discovery flows due to precise intent matching at the point of request.

Cart Abandonment Rate: High abandonment in the Agent API channel indicates pricing or shipping capability mismatches. Review your manifest to ensure declared shipping zones and payment methods align with actual checkout capabilities.

Average Order Value (AOV): AI agents often bundle complementary products based on user intent. Monitor AOV trends to identify cross-sell opportunities that agents are successfully exploiting.

Accelerating Your UCP Deployment with Expert Partners

Implementing UCP requires more than technical execution. It demands strategic alignment between your product catalog, pricing logic, and the emerging behaviors of AI shopping agents. Merchants who treat UCP as a pure engineering task often struggle with low agent recommendation rates despite technically correct implementations.

Book a discovery call with Presta to discuss how our Startup Studio can accelerate your UCP deployment while optimizing for AI discoverability. We help e-commerce brands architect UCP implementations that maximize conversion from agentic traffic, not just pass protocol compliance tests.

UCP Implementation for Custom E-Commerce Platforms

Merchants running custom e-commerce stacks (Laravel, Django, Node.js) have full control over UCP implementation but must build every component from scratch. This section provides a step-by-step framework for custom deployments.

Step 1: Host Your UCP Manifest

Create a publicly accessible endpoint at `https://yourdomain.com/.well-known/ucp` that serves your UCP manifest as JSON. Ensure the endpoint returns proper CORS headers to allow cross-origin requests from AI platforms:

Access-Control-Allow-Origin: * Access-Control-Allow-Methods: GET, OPTIONS Content-Type: application/json

Your manifest must declare the UCP version, service endpoints, capabilities, and payment handlers. Reference the official UCP specification at `ucp.dev` for the complete schema and required fields.

Step 2: Implement Core Capabilities

Build three REST endpoints to handle Checkout, Identity Linking, and Order Management:

Checkout Endpoint (`/ucp/checkout`) must accept POST requests containing cart items, shipping address, and payment token. The endpoint should:

Calculate taxes based on shipping address using your existing tax engine or a service like TaxJar.

Apply shipping rates from your shipping profile logic, ensuring rates match those declared in your UCP manifest.

Validate inventory availability in real-time, reserving stock atomically to prevent overselling.

Process the payment token via your payment processor (Stripe, Adyen, PayPal), ensuring PCI compliance by never logging or storing raw payment credentials.

Return a checkout session ID and order confirmation details in the response.

Identity Linking Endpoint (`/ucp/identity`) implements OAuth 2.0 authorization flows, allowing AI agents to request user consent for account-linked actions. This endpoint must:

Generate authorization codes with short expiration windows (5 minutes maximum).

Validate redirect URIs to prevent authorization code interception attacks.

Issue access tokens with scoped permissions (read-only for order history, read-write for cart modifications).

Order Management Endpoint (`/ucp/orders/webhook`) receives webhook subscriptions from AI agents and sends lifecycle event notifications (order shipped, delivered, returned). Implement webhook signature verification to ensure events originate from your server and have not been tampered with in transit.

Step 3: Secure Payment Integration with AP2

The Agent Payments Protocol (AP2) handles secure payment token exchange between AI agents and merchants. Your checkout endpoint must:

Accept tokenized payment credentials from the agent’s wallet provider (Google Pay, PayPal).

Send the token to your payment processor (Stripe, Adyen) for authorization and capture.

Never log or store the raw token, as it contains sensitive financial data.

Return transaction status (success, failure, pending) to the agent with appropriate error codes for retry logic.

Step 4: Test with Agent Simulations

Before going live, run Agent Simulations using automated scripts to test your UCP implementation. Simulate edge cases such as:

Out-of-stock products during checkout to verify your inventory reservation logic.

Invalid payment tokens to ensure proper error handling and user-friendly error messages.

High-concurrency requests to validate rate limiting and performance under load.

Webhook delivery failures to confirm retry logic and idempotency guarantees.

The official UCP documentation at `ucp.dev` provides conformance tests and sample repositories for validating your implementation against the protocol specification.

Data Quality: The Hidden UCP Success Factor

Technical correctness is necessary but insufficient for UCP success. AI agents prioritize stores with clean, structured product data. Poor data quality leads to low recommendation rates even with flawless protocol implementation.

Product Title Optimization

AI agents parse product titles to extract key attributes (brand, model, size, color). Avoid vague titles like “Premium Shirt” in favor of descriptive, structured titles: “Organic Cotton Crew Neck T-Shirt – Navy Blue – Size M – Brand Name”.

Use consistent naming conventions across your catalog. If some products use “Size M” while others use “Medium”, agents struggle to filter and compare products accurately, reducing your store’s relevance score.

Attribute Standardization

Map custom product attributes to standard UCP fields. Instead of ambiguous metafields like `custom_field_1`, use semantic labels: `Size`, `Color`, `Material`, `Brand`. AI agents rely on these standard attributes to filter products based on user intent.

Avoid text-heavy attribute values. Instead of “This product is made from 100% organic cotton and is machine washable”, use structured fields: `Material: 100% Organic Cotton`, `Care Instructions: Machine Washable`.

Inventory Accuracy

AI agents downrank stores with unreliable stock data. Implement real-time inventory synchronization with sub-second latency. If your inventory system updates every 15 minutes, you risk selling out-of-stock products, which damages agent trust scores and reduces future recommendation frequency.

Use inventory reservation logic to hold stock during checkout sessions. Reserve items for 10 minutes when an agent initiates checkout, releasing the reservation if the transaction is not completed within that window.

Policy Clarity

Establish machine-readable return and shipping policies. Instead of prose descriptions (“We offer free shipping on orders over $50 to the continental US”), use structured data:

json { "shipping_policy": { "free_shipping_threshold": 50, "currency": "USD", "regions": ["US-CONTINENTAL"] } }

Ensure your Shopify Shipping Profiles (or equivalent in custom platforms) are precise and granular. Vague shipping zones like “North America” should be broken down into specific regions (US, Canada, Mexico) with accurate rate calculations for each.

Security and Compliance for UCP

UCP implementations must enforce robust security measures to protect user data and prevent fraudulent transactions. The following security requirements are non-negotiable.

Authentication Mechanisms

Implement mutual TLS (mTLS) or OAuth 2.0 flows for agent authentication. Mutual TLS ensures both the agent and your server verify each other’s identities before exchanging data, preventing man-in-the-middle attacks.

For OAuth 2.0, use short-lived access tokens (1 hour maximum) with refresh token rotation. Invalidate tokens immediately upon logout or suspicious activity detection.

Input Validation

Validate all incoming data against strict schemas. Reject malformed requests with HTTP 400 errors and detailed error messages that help agents correct their requests without exposing internal system details.

Use allowlists for critical fields like payment methods and shipping regions. If your manifest declares support for Google Pay and PayPal, reject requests attempting to use unsupported methods like cryptocurrency or bank transfers.

Principle of Least Privilege

Grant AI agents the minimum permissions required to complete their tasks. For product discovery, provide read-only access to catalog data. For checkout, allow cart creation and payment processing but not account modification or order cancellation.

Implement role-based access control (RBAC) to separate agent permissions from user permissions. An agent acting on behalf of a user should inherit the user’s permissions but never exceed them.

Webhook Signature Verification

Sign all webhook payloads with HMAC-SHA256 using a shared secret. Agents must verify signatures before processing webhook events to ensure data integrity and authenticity.

Implement replay attack protection by including timestamps in webhook payloads and rejecting events older than 5 minutes. This prevents attackers from capturing and replaying legitimate webhook events to trigger duplicate actions.

Measuring Success: KPIs and Proof Points

UCP implementation success is measured by AI agent recommendation rates, conversion from agentic traffic, and revenue attribution to AI-driven discovery. Track these metrics 30, 60, and 90 days post-launch.

30-Day Metrics: Technical Validation

Agent Discovery Rate: Percentage of AI platforms successfully discovering and parsing your UCP manifest. Target 95% or higher. Low discovery rates indicate manifest schema errors or accessibility issues.

API Response Time: Average response time for product discovery (target: sub-200ms) and checkout (target: sub-500ms). Slow endpoints reduce agent recommendation frequency.

Error Rate: Percentage of agent requests resulting in HTTP 4xx or 5xx errors. Target below 1%. High error rates signal implementation bugs or infrastructure instability.

60-Day Metrics: Engagement and Conversion

Agent Recommendation Frequency: How often AI agents recommend your products in response to user queries. This metric is platform-specific and requires integration with agent analytics dashboards (Google AI Mode, ChatGPT Commerce Analytics).

Conversion Rate from AI Discovery: Percentage of agent-initiated sessions that result in completed purchases. Early 2026 benchmarks show 28% higher conversion from AI-driven discovery compared to traditional search traffic.

Cart Abandonment Rate: Percentage of agent-initiated carts that are not completed. High abandonment indicates pricing mismatches, shipping capability gaps, or payment method limitations.

90-Day Metrics: Revenue and ROI

Revenue from Agentic Traffic: Total revenue attributed to AI-driven discovery and checkout. Track this separately from traditional web traffic to measure UCP ROI.

Average Order Value (AOV): Compare AOV from agentic traffic versus traditional web traffic. AI agents often bundle complementary products, leading to higher AOV.

Customer Acquisition Cost (CAC): Calculate CAC for customers acquired through AI agents versus traditional channels. Early data suggests lower CAC for agentic traffic due to precise intent matching and reduced ad spend.

Common UCP Implementation Pitfalls

Even technically correct UCP implementations can fail to generate meaningful agentic traffic. Avoid these common mistakes:

Incomplete Capability Declarations

Declaring capabilities in your manifest that your endpoints do not actually support leads to agent errors and trust score penalties. If your manifest claims support for loyalty points but your checkout endpoint rejects loyalty point redemption requests, agents will downrank your store.

Test every declared capability with automated scripts before going live. Use the conformance tests provided in the official UCP documentation to validate endpoint behavior.

Currency Hallucinations

Failing to explicitly set `priceCurrency` in every `Offer` object causes agents to guess currency based on domain TLD or user location. This leads to incorrect price displays and transaction failures.

Always declare currency explicitly: `”priceCurrency”: “USD”` for every product offer, even if your store only operates in a single currency.

Stale Inventory Data

Serving cached inventory data without real-time synchronization results in overselling and order cancellations. AI agents track merchant reliability scores, and frequent cancellations due to stock-outs permanently damage your recommendation ranking.

Implement webhook-based cache invalidation. When inventory levels change, immediately invalidate cached product data and refresh the UCP feed.

Ignoring Agent Feedback Loops

AI platforms provide merchant dashboards with agent interaction analytics (recommendation frequency, error rates, user satisfaction scores). Ignoring this feedback prevents you from identifying and fixing implementation issues.

Review agent analytics weekly during the first 90 days post-launch. Look for patterns in error codes, abandoned carts, and low recommendation rates to identify optimization opportunities.

The Future of UCP: Roadmap and Extensions

UCP is designed as a modular, extensible protocol. The initial 1.0 release focuses on core commerce capabilities, but the roadmap includes advanced features for 2026 and beyond.

Multi-Item Carts and Bundling

The initial UCP specification supports single-item checkouts. Future versions will enable multi-item carts with dynamic bundling logic, allowing agents to negotiate bulk discounts and shipping optimizations across multiple products.

Account Linking and Personalization

Enhanced identity linking will enable agents to access user purchase history, wishlists, and saved payment methods. This allows for personalized product recommendations and one-click reordering of frequently purchased items.

Subscription Management

UCP extensions for subscription commerce will enable agents to create, modify, and cancel recurring orders. This is critical for consumable products (coffee, vitamins, pet food) where AI agents can proactively reorder based on usage patterns.

Returns and Refunds

Future UCP capabilities will standardize return initiation and refund processing, allowing agents to handle post-purchase support without requiring users to navigate merchant return portals.

Frequently Asked Questions

What is the difference between UCP and ACP?

UCP (Universal Commerce Protocol) is developed by Google and Shopify for search-to-buy experiences across Google AI Mode and the open web. ACP (Agentic Commerce Protocol) is developed by OpenAI and Stripe for chat-to-buy interactions within conversational AI assistants like ChatGPT. UCP supports more complex commerce workflows, including post-purchase order management and OAuth-based identity linking, while ACP prioritizes rapid deployment for embedded checkout within AI chat interfaces. Merchants should implement both protocols to maximize visibility across AI-driven shopping surfaces.

How long does UCP implementation take?

Shopify merchants using the native Universal Commerce Agent app can deploy UCP in under 48 hours, including configuration and testing. Custom e-commerce platforms require 2-4 weeks for full implementation, depending on existing infrastructure readiness. Headless Shopify setups with custom middleware typically take 1-2 weeks. The primary time investment is not coding but data quality optimization: cleaning product titles, standardizing attributes, and ensuring inventory accuracy.

Do I need to implement UCP if I already have ACP?

Yes. UCP and ACP target different AI platforms and user behaviors. ACP powers conversational commerce within ChatGPT and similar assistants, while UCP enables discovery and purchase through Google AI Mode, Gemini, and future Google Shopping integrations. Implementing only one protocol limits your addressable market. Early 2026 data shows merchants with dual UCP/ACP implementation capturing 40% more agentic traffic than single-protocol stores.

What are the security requirements for UCP?

UCP implementations must enforce mutual TLS or OAuth 2.0 for agent authentication, HMAC-SHA256 signature verification for webhooks, and strict input validation against defined schemas. Payment tokens must never be logged or stored, and all transactions must comply with PCI DSS standards. Implement rate limiting to prevent abuse, and use the principle of least privilege to grant agents only the permissions required for their specific tasks. Regular security audits and penetration testing are recommended, especially for custom implementations handling high transaction volumes.

How do AI agents rank and recommend products?

AI agents use multi-factor ranking algorithms that consider product relevance to user intent, merchant reliability scores (based on historical order fulfillment and cancellation rates), API response times, data quality (structured attributes, accurate inventory), and user satisfaction metrics (post-purchase reviews, return rates). Agents also factor in pricing competitiveness and shipping speed. Merchants with clean data, fast APIs, and reliable fulfillment consistently outrank competitors with technically correct but poorly optimized UCP implementations.

Can I use UCP with WooCommerce or Magento?

Yes, but it requires custom development. Unlike Shopify’s native UCP support, WooCommerce and Magento do not provide official UCP plugins as of January 2026. You must build custom endpoints for checkout, identity linking, and order management, then host your UCP manifest at `/.well-known/ucp`. Consider migrating to Shopify for faster UCP deployment and ongoing protocol updates. Learn more about WooCommerce to Shopify migration to accelerate your agentic commerce readiness.

What happens if my UCP implementation has errors?

AI agents will retry failed requests up to 3 times with exponential backoff. After 3 failures, agents mark your store as temporarily unavailable and reduce recommendation frequency. Persistent errors (error rate above 5% over 24 hours) result in long-term trust score penalties, significantly reducing future recommendation rates. Monitor error logs closely during the first 30 days post-launch and fix issues immediately to avoid permanent ranking damage.

How do I test my UCP implementation before going live?

Use the conformance tests and sample repositories provided in the official UCP documentation at `ucp.dev`. Run automated agent simulations to test edge cases like out-of-stock products, invalid payment tokens, and high-concurrency requests. Validate your manifest schema using the official JSON schema validator. For Shopify merchants, enable the Agent API sales channel in test mode to simulate agent traffic without affecting live sales. Custom implementations should use staging environments with production-identical data to catch integration issues before launch.

What is the ROI timeline for UCP implementation?

Early adopters (January-March 2026) are seeing measurable traffic from Google AI Mode within 30 days of launch, with revenue attribution becoming significant by day 60. Conversion rates from agentic traffic average 28% higher than traditional search traffic due to precise intent matching. However, ROI depends heavily on data quality and implementation optimization. Stores with clean product data and fast APIs see positive ROI within 90 days, while poorly optimized implementations may take 6+ months to generate meaningful revenue.

How does UCP handle international commerce?

UCP supports multi-currency pricing and region-specific shipping policies through structured manifest declarations. Declare supported currencies in your `Offer` objects and define shipping zones with precise geographic boundaries (country codes, postal code ranges). AI agents will automatically filter products and calculate shipping based on user location. For tax calculation, integrate with services like TaxJar or Avalara to ensure compliance with local tax regulations. International UCP implementations must also consider language localization for product titles and descriptions, as agents use natural language processing to match user queries to product catalogs.

How to Implement Universal Commerce Protocol (UCP) in 2026: Complete /.well-known/ucp Setup Guide