UCP Merchant Center Onboarding: The Simplified Path Google Just Launched

Google Just Made UCP Onboarding Significantly Easier

Getting a new merchant live on UCP used to involve multiple separate steps spread across at least two different systems. As of late March 2026, Google has shipped a consolidated onboarding flow inside Google Merchant Center that collapses most of that process into a single guided experience.

If you are a merchant on Shopify or another platform with UCP support, or if you have a custom UCP implementation already deployed, the new flow changes your time-to-live from days to minutes in many cases.

Here is what changed, how it works technically, and how to use it.

What the Old Process Looked Like

Before this update, a merchant who wanted to be discoverable through Google's UCP infrastructure needed to do several things independently:

First, they had to configure their UCP manifest manually at /.well-known/ucp and verify it was accessible and correctly formatted. There was no Google-side tooling to help with this. You had to run the conformance test suite yourself or use a third-party validator.

Second, they had to register their UCP endpoint with Google Merchant Center through a form-based process that required submitting the manifest URL, waiting for a manual review cycle, and then receiving a confirmation. That review cycle could take anywhere from 24 hours to several days, depending on volume.

Third, Google ran a one-time verification check at the time of registration. If anything in the manifest failed, the merchant received an error notification and had to fix the issue and resubmit. There was no continuous re-verification. If a manifest degraded after initial approval (wrong endpoint, changed capabilities, expired tokens), Google's index would continue to show the merchant as UCP-enabled even if the implementation was broken.

The process worked, but it was manual, slow, and created a persistent risk of stale status in Google's merchant registry.

The New Flow: What Google Changed

The new onboarding flow, available in Google Merchant Center under the "UCP" section in the left navigation, does three things the old process did not:

Auto-detection. When you click "Set up UCP," Merchant Center immediately crawls /.well-known/ucp on your domain and displays what it finds. If you have a valid manifest, the flow populates your endpoint information automatically. You review it rather than entering it from scratch.

Inline conformance validation. Google runs its own conformance checks against your endpoints during the onboarding flow, not as a separate step after submission. The results are displayed in real time, organized by capability area: Discovery, Checkout, Identity, and Order Management. Each check shows pass/fail status with a plain-English description of what was tested and what failed if applicable.

One-click enablement. Once your manifest is detected and your endpoints pass the conformance checks, enabling UCP in Google's infrastructure is a single confirmation. There is no separate review queue. Approval is automated based on the conformance results.

The combination of these three changes eliminates most of the time that the old process consumed. For a merchant with a working UCP implementation, the entire flow from opening Merchant Center to being live in Google's agent infrastructure now takes under ten minutes.

The Technical Layer: How Google Validates Your Manifest

Understanding what Google is actually checking during the inline conformance step is useful both for debugging failures and for building implementations that pass cleanly the first time.

Manifest structure validation. Google parses your /.well-known/ucp JSON document and validates it against the current UCP manifest schema. This includes checking that all required fields are present (version, endpoints, capabilities), that endpoint URLs are reachable and return correct content types, and that capability declarations match what the endpoints actually support.

Endpoint reachability. Google makes live requests to each declared endpoint using test parameters defined in the UCP conformance specification. For discovery endpoints, it sends a structured product search request and validates that the response conforms to the UCP product schema. For checkout endpoints, it initiates a test session (using a reserved test identity token that does not create real orders) and validates the session response.

Capability consistency. If your manifest declares Identity support but your identity endpoint returns 404, the validation will flag the inconsistency. Google does not trust the manifest declaration alone. It tests each declared capability independently.

Response time thresholds. Google's validation includes latency checks. Discovery endpoints need to respond within a defined threshold (currently 500ms for the validation check, though production agent traffic expects lower). Endpoints that pass all structural checks but fail on response time will generate a warning rather than a blocking failure, with a recommendation to optimize before going live at scale.

HTTPS requirement. All UCP endpoints, including the manifest itself, must be served over HTTPS with a valid certificate. HTTP endpoints are rejected at the manifest detection stage.

The Merchant Registry: How It Stays Current

One of the most significant changes in the new flow is the shift from one-time verification to continuous re-verification.

After a merchant enables UCP through the new flow, Google's infrastructure crawls the /.well-known/ucp manifest on a recurring schedule. The current interval is not publicly documented, but behavior suggests daily re-validation at minimum. If a manifest changes (new capabilities added, endpoint URLs updated, capabilities removed), Google's index updates automatically.

If a previously passing endpoint begins failing conformance checks, Google flags the implementation as degraded in its registry. Agents querying Google's merchant index see a status indicator. The merchant receives a notification in Merchant Center with the specific check that failed. The merchant is not immediately removed from the index, but degraded implementations are deprioritized in agent discovery results until the issue is resolved.

This continuous model is better for agents (fewer broken integrations at query time) and better for merchants (faster recovery when something breaks, rather than waiting for a manual review to catch the issue).

Step-by-Step: Walking Through the New Onboarding

Here is the complete flow from a merchant's perspective:

Step 1: Open Google Merchant Center and navigate to "UCP" in the left sidebar. If you do not see this option, your account may need to be on a Merchant Center Next account. The UCP section is not available in legacy Merchant Center.

Step 2: Click "Set up UCP." Merchant Center will prompt you to confirm your primary domain if it is not already set. Enter your domain and click "Detect manifest."

Step 3: Review the auto-detected manifest. If your /.well-known/ucp endpoint is correctly configured, Merchant Center displays your manifest contents. Confirm the endpoint URLs and capability declarations look correct. If detection fails, Merchant Center shows an error with a description of why. The most common causes are a missing manifest file, an invalid JSON structure, or a non-HTTPS endpoint.

Step 4: Run conformance checks. Click "Validate endpoints." Google runs the inline conformance suite against your declared endpoints. This takes 30-60 seconds. Results appear organized by capability area. Address any blocking failures before proceeding. Warnings can be resolved after going live, but blocking failures prevent enablement.

Step 5: Enable UCP. Click "Enable UCP" to activate your endpoints in Google's merchant registry. You will receive a confirmation that your store is now discoverable by agents through Google's infrastructure.

Step 6: Verify in the directory. Submit or update your listing at UCPList.ai to ensure your store is visible to developers and agent builders outside the Google ecosystem as well.

Who Benefits Most from This Change

The new flow benefits all merchants, but the impact is largest for two groups.

Small merchants on Shopify. If you are a Shopify merchant on a plan that includes UCP support, your implementation is handled by Shopify's platform integration. The technical work is already done. The old Merchant Center process was the remaining friction. The new flow removes that friction almost entirely. You are navigating a UI, not doing engineering work.

New UCP adopters who have just finished their implementation. Previously, completing a UCP implementation and waiting several days for Google's review cycle was a frustrating gap. The new flow closes that gap. You finish implementing, you run the conformance checks, you enable. Same session.

For large enterprise merchants running custom implementations, the new flow is still an improvement, but the bigger time investments are in the implementation itself, not the registration. The onboarding change is more impactful for the long tail.

Before You Start: Make Sure Your Manifest Is Ready

The new flow does not eliminate the need for a correct implementation. It just makes the verification step faster and more transparent.

Before starting onboarding, make sure your /.well-known/ucp manifest is deployed and accessible. Run the open source conformance test suite locally before attempting the Merchant Center flow. Fixing failures locally is faster than iterating through the Merchant Center UI.

Check our developer implementation guide if you are working through a custom implementation and need a reference for what a conformant endpoint looks like. The conformance test suite documentation also describes what each check tests in detail.

Once you are live in Google's registry and in the UCPList directory, your implementation will be accessible to the growing ecosystem of agent builders who are looking for UCP-enabled merchants to integrate with. The onboarding friction was always a solvable problem. Google just solved it.