How to Implement the Universal Commerce Protocol in 6 Steps (Complete Technical Guide)

The Universal Commerce Protocol launched January 2026 with backing from Google, Shopify, and 20+ retail partners including Target, Walmart, and Wayfair. If you want your products purchasable directly inside Google AI Mode and Gemini, you need to implement UCP.

I’ve spent the past week digging through the UCP specification, Google’s integration guide, and Shopify’s engineering documentation. This guide walks you through the complete implementation process, from Merchant Center configuration to production deployment.

What’s Covered

What You’ll Need

Before starting, gather these requirements:

• Google Merchant Center account with products eligible for checkout
• Product data feed with accurate inventory and pricing
• Payment processor integration (Stripe, Adyen, Google Pay, or similar)
• Development environment capable of hosting REST APIs
• Return policy documentation configured in Merchant Center
• Shipping configuration with rates and delivery windows
• Customer support contact information

Time estimate: 1 to 2 weeks for basic implementation, 4 to 6 weeks for full production deployment with Google approval.

Step 1. Configure Your Merchant Center Account

Start by ensuring your Merchant Center account meets UCP requirements. Google requires specific configurations before you can enable agentic checkout on AI surfaces.

Why it matters: UCP uses your existing Merchant Center product data to surface inventory in AI Mode and Gemini. Missing configurations will block your products from checkout eligibility. According to Google’s UCP documentation, return policies and customer support information are mandatory Merchant of Record requirements.

How to do it:

1. Log into Google Merchant Center
2. Navigate to Settings > Shipping and returns
3. Configure return policies with: return cost, return window (days), and link to full policy
4. Set up shipping rates for all regions you serve
5. Go to Settings > Business information and add customer support email and phone
6. If using an advanced account, configure policies at each sub-account level

Common mistake: Configuring policies only at the parent account level when using advanced accounts. Each sub-account needs its own return policy configuration.

Step 2. Update Your Product Feed for UCP Eligibility

Add UCP-specific attributes to your product feed to signal checkout eligibility. Google recommends using a supplemental feed to avoid impacting your primary product data.

Why it matters: Products without the native_commerce attribute will not appear in agentic checkout experiences. The product ID in your feed must also match the ID expected by your Checkout API, or you need to provide a mapping via merchant_item_id.

How to do it:

1. Create a supplemental data source in Merchant Center
2. Add the native_commerce attribute set to TRUE for eligible products
3. Add consumer_notice for products requiring regulatory warnings (e.g., Prop 65)
4. Add merchant_item_id if your checkout system uses different product IDs
5. Upload the supplemental feed and verify products show as checkout-eligible

Example supplemental feed (XML):

<item>
  <g:id>SKU-12345</g:id>
  <g:native_commerce>TRUE</g:native_commerce>
  <g:consumer_notice>
    <g:consumer_notice_type>prop_65</g:consumer_notice_type>
    <g:consumer_notice_message>This product can expose you to chemicals known to the State of California to cause cancer.</g:consumer_notice_message>
  </g:consumer_notice>
  <g:merchant_item_id>checkout-sku-12345</g:merchant_item_id>
</item>

Step 3. Publish Your Business Profile

Create and host your UCP business profile at a well-known endpoint. This profile declares which capabilities you support and how agents should communicate with your systems.

Why it matters: UCP uses dynamic discovery. Agents query your profile to understand what capabilities you offer (checkout, identity linking, order management), which extensions you support (discounts, fulfillment options), and which payment handlers you accept. Without a published profile, agents cannot initiate transactions with your business.

How to do it:

1. Create a JSON file following the UCP profile schema
2. Declare your supported services (start with dev.ucp.shopping)
3. List your capabilities: dev.ucp.shopping.checkout at minimum
4. Add extensions you support: discount, fulfillment, identity_linking
5. Specify payment handlers with public keys for signature verification
6. Host the profile at https://yourdomain.com/.well-known/ucp.json

Example business profile:

{
  "ucp": {
    "version": "2026-01-11",
    "services": {
      "dev.ucp.shopping": {
        "version": "2026-01-11",
        "spec": "https://ucp.dev/specs/shopping",
        "rest": {
          "schema": "https://ucp.dev/services/shopping/openapi.json",
          "endpoint": "https://api.yourstore.com/ucp/"
        }
      }
    },
    "capabilities": [
      {
        "name": "dev.ucp.shopping.checkout",
        "version": "2026-01-11"
      },
      {
        "name": "dev.ucp.shopping.discount",
        "version": "2026-01-11",
        "extends": "dev.ucp.shopping.checkout"
      },
      {
        "name": "dev.ucp.shopping.fulfillment",
        "version": "2026-01-11",
        "extends": "dev.ucp.shopping.checkout"
      }
    ]
  },
  "payment": {
    "handlers": [
      {
        "id": "google_pay",
        "name": "com.google.pay"
      },
      {
        "id": "stripe",
        "name": "com.stripe.payments"
      }
    ]
  }
}

Common mistake: Forgetting to version your capabilities. UCP uses semantic versioning, and agents may behave differently based on the version you declare.

Step 4. Build the Checkout API

Implement the core checkout capability with endpoints for creating, updating, and completing checkout sessions. UCP checkouts follow a state machine pattern with defined transitions.

Why it matters: The checkout capability is the core of UCP. Your implementation must handle the full checkout lifecycle: cart creation, buyer information collection, payment processing, and order confirmation. According to Shopify’s UCP engineering documentation, the protocol models checkout as a state machine to handle both fully automated and human-assisted transactions.

Checkout states:

• incomplete: Missing required information. Agent should resolve via API.
• requires_escalation: Buyer input required. Provide continue_url for handoff.
• ready_for_complete: All information collected. Agent can finalize.
• complete_in_progress: Processing the completion request.
• completed: Order placed successfully.
• canceled: Session invalid or expired.

How to do it:

1. Implement POST /checkout to create a new checkout session
2. Implement PATCH /checkout/{id} to update session with buyer information
3. Implement POST /checkout/{id}/complete to finalize the order
4. Return structured error messages with severity field for agent guidance
5. Include continue_url when human escalation is required

Example checkout response:

{
  "ucp": {"version": "2026-01-11"},
  "id": "chk_abc123",
  "status": "incomplete",
  "line_items": [
    {
      "id": "li_1",
      "product_id": "SKU-12345",
      "quantity": 1,
      "price": {"amount": "49.99", "currency": "USD"}
    }
  ],
  "totals": {
    "subtotal": {"amount": "49.99", "currency": "USD"},
    "tax": {"amount": "4.50", "currency": "USD"},
    "total": {"amount": "54.49", "currency": "USD"}
  },
  "messages": [
    {
      "code": "missing_shipping_address",
      "severity": "requires_platform_input",
      "message": "Shipping address is required"
    }
  ],
  "payment": {
    "handlers": ["google_pay", "stripe"]
  }
}

Step 5. Configure Payment Handlers and AP2

Set up payment handler integration using the Agent Payments Protocol (AP2). AP2 provides cryptographically-verified authorization for agentic transactions.

Why it matters: UCP separates payment instruments (what buyers use to pay) from payment handlers (how payments are processed). This architecture lets you keep your existing payment processor relationships while enabling new instruments like Google Pay. AP2 mandate chains provide proof of user consent for every transaction, critical for fraud prevention and compliance.

How to do it:

1. Register your supported payment handlers in your business profile
2. Implement the payment handler callback endpoint
3. Configure AP2 mandate verification using your payment processor’s SDK
4. Store and verify mandate chain signatures before processing payments
5. Handle payment failures gracefully with appropriate error codes

Payment handler negotiation flow:

1. Agent sends profile declaring available instruments (Google Pay, card tokens)
2. Your checkout responds with compatible handlers for the cart
3. Buyer selects payment method and authorizes via instrument provider
4. Agent receives tokenized payment data and mandate chain
5. Your system verifies mandate and processes payment through handler

Step 6. Test and Submit for Google Approval

Validate your implementation against UCP conformance tests and submit to Google for review. Your integration must be approved before going live on AI Mode and Gemini.

Why it matters: Google reviews all UCP implementations to ensure they meet security and user experience standards. Skipping conformance testing will delay approval and require rework. The UCP GitHub repository provides conformance tests you can run locally.

How to do it:

1. Clone the UCP conformance test suite from GitHub
2. Run tests against your staging environment
3. Fix any failures, paying special attention to error handling and state transitions
4. Test the full checkout flow manually: discovery, cart creation, payment, completion
5. Join the Google UCP waitlist to request review
6. Work with Google’s team to resolve any issues during review

Conformance test categories:

• Profile discovery: Verifies your well-known endpoint returns valid schema
• Checkout lifecycle: Tests state transitions and error handling
• Payment handling: Validates mandate verification and token processing
• Escalation flow: Confirms continue_url behavior for human handoff

Final Thoughts

UCP represents the infrastructure layer for agentic commerce. Early implementers will capture AI-driven traffic as Google expands AI Mode and Gemini shopping features. The protocol is designed to work with your existing checkout infrastructure, not replace it.

Start with the core checkout capability. Add extensions (discounts, fulfillment, identity linking) after your basic flow works. The modular architecture means you can expand incrementally without breaking existing functionality.

For how UCP compares to OpenAI’s Agent Commerce Protocol, see my UCP vs ACP comparison guide.

Which step will you start with today?