5 Things You Can Build with UCP Today

UCP has been live for about two months. The spec is solid, there are real merchants with working endpoints, and the developer tooling is better than you'd expect for something this new. Here are five things you can actually build with it today.

1. Price Comparison Agent

The most obvious UCP application and still the most compelling one. Because UCP merchants expose structured product data through a standard API, you can query multiple stores simultaneously and compare prices without scraping HTML.

// Fetch UCP manifests from multiple merchants
const merchants = [
  'https://www.allbirds.com/.well-known/ucp',
  'https://www.glossier.com/.well-known/ucp',
];

const manifests = await Promise.all(
  merchants.map(url => fetch(url).then(r => r.json()))
);

// Each manifest tells you the merchant's MCP transport endpoint
// and supported capabilities (checkout, fulfillment, etc.)
for (const manifest of manifests) {
  console.log(manifest.name, manifest.mcp_transport);
  console.log('Capabilities:', manifest.capabilities);
}

Start with the verified merchants in our directory. There are 47 merchants with confirmed live endpoints. Query their catalogs, normalize the results, and build a comparison UI. You could have a working prototype in a weekend.

Check our UCP Checker tool to verify endpoints are responding before you build against them.

2. Checkout Assistant

Take the price comparison a step further: build an agent that can actually complete a purchase. UCP's checkout flow is standardized, so once you've implemented it for one merchant, it works for all of them.

// After discovering products, initiate checkout
const checkoutSession = await fetch(merchant.mcp_transport, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    method: 'create_checkout',
    params: {
      product_id: selectedProduct.id,
      variant_id: selectedVariant.id,
      quantity: 1,
      // UCP uses tokenized payments - never raw card numbers
      payment_token: userPaymentToken,
      shipping_address: userAddress,
    },
  }),
});

const result = await checkoutSession.json();
// Consumer gets a confirmation prompt before the charge goes through
console.log('Checkout URL:', result.confirmation_url);

The key design principle in UCP is "agents propose, humans approve." Your agent handles discovery and assembly, but the consumer confirms before any money moves. This is built into the protocol, not something you need to implement yourself.

The building an AI shopping agent guide covers the full flow in detail.

3. Multi-Merchant Cart

Here's one that doesn't exist yet (as far as we know): a unified shopping cart that spans multiple UCP merchants.

The idea is simple. A consumer tells their agent "I need running shoes, a water bottle, and a yoga mat." The agent finds the best option for each item across different merchants, adds them all to a single cart view, and the consumer checks out everything at once.

UCP makes this possible because the checkout flow is standardized. Your app manages the cart state, creates separate checkout sessions with each merchant, and presents them as one unified experience.

// Build a multi-merchant cart
const cart = [
  { merchant: 'allbirds.com', product: 'Tree Runners', price: 98 },
  { merchant: 'glossier.com', product: 'Body Hero Wash', price: 18 },
];

// Create checkout sessions in parallel
const checkouts = await Promise.all(
  cart.map(item =>
    createUCPCheckout(item.merchant, item.product)
  )
);

// Present unified confirmation to user
// Each merchant processes their own payment independently

This is the kind of project that shows off what UCP enables that wasn't possible before. Browse the full merchant directory to find stores across different product categories.

4. UCP Validator Tool

We built one of these ourselves (check it out at /tools/validator), but there's room for more specialized versions.

A validator fetches a merchant's /.well-known/ucp manifest, checks that it conforms to the UCP specification, verifies the MCP transport endpoint is reachable, and tests the supported capabilities.

async function validateUCPEndpoint(domain: string) {
  const manifestUrl = `https://${domain}/.well-known/ucp`;

  try {
    const response = await fetch(manifestUrl);
    if (!response.ok) {
      return { valid: false, error: `HTTP ${response.status}` };
    }

    const manifest = await response.json();

    // Check required fields
    const required = ['name', 'mcp_transport', 'capabilities'];
    const missing = required.filter(f => !(f in manifest));

    if (missing.length > 0) {
      return { valid: false, error: `Missing: ${missing.join(', ')}` };
    }

    // Test MCP transport endpoint
    const transportCheck = await fetch(manifest.mcp_transport, {
      method: 'OPTIONS',
    });

    return {
      valid: true,
      manifest,
      transportReachable: transportCheck.ok,
    };
  } catch (err) {
    return { valid: false, error: err.message };
  }
}

You could build a validator that goes deeper than ours: test actual product search queries, validate response schemas against the UCP Schema, check SSL configurations, or benchmark response times. The conformance test suite is a great reference for what to test.

You can also use our manifest generator to create test fixtures for your validator.

5. Inventory Monitor

Build a service that tracks product availability across UCP merchants. Because UCP endpoints return structured inventory data, you can poll them periodically and alert users when items come back in stock or drop in price.

// Monitor a product across UCP merchants
async function checkInventory(merchantDomain: string, productId: string) {
  const manifest = await fetch(
    `https://${merchantDomain}/.well-known/ucp`
  ).then(r => r.json());

  const result = await fetch(manifest.mcp_transport, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      method: 'search_products',
      params: { product_id: productId },
    }),
  });

  const product = await result.json();
  return {
    available: product.in_stock,
    price: product.price,
    variants: product.variants?.map(v => ({
      name: v.name,
      available: v.in_stock,
    })),
  };
}

This is especially useful for limited-edition drops or popular items that sell out fast. Set up a cron job, track changes over time, and notify users through whatever channel they prefer.

Getting Started

All of these projects start the same way: pick a merchant from the UCPList directory, fetch their manifest, and start experimenting. The developer tools category has SDKs and testing utilities to help.

The ecosystem is early, which means there's a lot of room for tools that don't exist yet. If you build something cool, submit it to the directory so others can find it too.