NEW WooCommerce plugin is live โ€” Read the install guide โ†’
Insights / Nov 11, 2026

UCP Manifest JSON Example: The Complete 2026 Setup Guide

UCP Manifest JSON Example: The Complete 2026 Setup Guide

A merchant called us last spring in a quiet panic. Their store had been live with what they believed was a working UCP integration for six weeks, and an AI shopping agent had been trying to parse their catalog the entire time. The problem was not their products, their pricing, or their inventory. It was a single UCP manifest JSON example they had copied from a forum post, pasted into their `.well-known` directory, and never validated. The file had a trailing comma on line 34. Agents hitting that endpoint silently rejected the whole document. Nothing errored visibly. Nothing logged loudly. The store simply became invisible to agentic buyers for a month and a half, and the only signal was a flat line in a traffic segment nobody was watching yet.

That is the exact failure mode we built this guide to prevent. A UCP manifest is the single most load-bearing file in your entire agentic commerce setup, and in our experience the gap between “it looks right” and “it is actually valid and discoverable” is where almost every real-world problem lives. In this guide we will walk through a complete, working UCP manifest JSON example, explain every field, show you where the file has to live, how to validate it, how to optimize it for real agent behavior, and the specific mistakes we see merchants make week after week. We write UCP infrastructure for a living, so this is the version we wish every store started from instead of the forum copy-paste.

TL;DR

  • Correct placement beats clever content: Your manifest must sit at `https://yourdomain.com/.well-known/ucp/manifest.json`, return HTTP 200 with `Content-Type: application/json`, and be reachable without auth, redirects, or JavaScript rendering, or no agent will ever see it.
  • A valid UCP manifest JSON example is strict JSON, not JSON5: No trailing commas, no comments, all keys double-quoted, UTF-8 encoded, with a declared protocol version and at least one capability endpoint that actually resolves and returns live data.
  • Conformance is necessary but not sufficient: UCP Checker, which independently monitors 20,120+ storefronts, reports roughly 81% pass full UCP validation (16,376 verified), but a conformant manifest is not the same as an agent being able to complete a real checkout, so validate behavior, not just syntax.

Getting Started: What a UCP Manifest Actually Is and Why It Lives at a Well-Known Path

Before we paste a single line of JSON, we want to be precise about what this file does, because the mental model is where most teams go wrong. The UCP manifest is the discovery and capability document for your store. When an AI agent wants to shop, transact, or query your catalog on behalf of a human, it does not guess. It fetches a predictable, standardized URL and reads a machine-readable declaration of who you are, what protocol version you speak, and which operations you support. If you have read our definitive guide to what UCP is, you already know UCP is the contract layer between your commerce backend and the agentic web. The manifest is the front door of that contract.

Why a well-known path: The `.well-known` convention comes from RFC 8615, the same mechanism that powers things like `security.txt` and OAuth discovery. The entire point is zero-configuration discoverability. An agent that has never seen your domain before should be able to construct the manifest URL from your domain alone. That is why the location is non-negotiable and why we tell clients to treat it like a DNS record: boring, stable, and never moved on a whim.

The canonical location: For UCP, the manifest lives at `/.well-known/ucp/manifest.json`. Note the nested `ucp` directory. We see a surprising number of stores place a file at `/.well-known/manifest.json` or `/manifest.json`, which collides with the Web App Manifest spec and means agents looking for UCP find nothing. The nesting is deliberate and it matters.

What it is not: The manifest is not your product feed. It does not contain your 40,000 SKUs. It is a thin pointer document that declares capability endpoints, and those endpoints are where the heavy catalog, pricing, and checkout data actually live. We cover why this separation matters for crawlability in our piece on machine-readable commerce and product data. Conflating the manifest with the feed is the single most common architectural misunderstanding we untangle.

Here is your getting-started checklist before you write any JSON:

  • Domain confirmed: Decide the exact canonical domain agents will use, including whether you serve from the apex or `www`, and commit to one with a 301 from the other.
  • TLS verified: Confirm your certificate is valid and not expiring inside 30 days, because agents will refuse an insecure manifest fetch.
  • Path reserved: Make sure your server or platform lets you serve a static file at a nested `.well-known/ucp/` path without rewrites stripping it.
  • Backend inventory: List which capabilities you can actually honor today (catalog read, pricing, checkout) so you only declare endpoints that work.
  • Version decided: Pin the UCP protocol version you are building against so your manifest and your endpoints agree.

The Core UCP Manifest JSON Example You Can Build From

Here is a complete, realistic UCP manifest JSON example for a mid-sized merchant. This is the shape we start every implementation from, trimmed to the fields that carry weight. Read it once, then we will go field by field.

{ "ucp_version": "1.0", "manifest_version": "2026-01-15", "merchant": { "id": "merchant_8f3a21c0", "legal_name": "Northbound Supply Co.", "display_name": "Northbound Supply", "domain": "northboundsupply.com", "support_email": "[email protected]", "country": "US" }, "capabilities": { "catalog": { "supported": true, "endpoint": "https://northboundsupply.com/ucp/v1/catalog", "formats": ["application/json"], "updated_frequency": "hourly" }, "pricing": { "supported": true, "endpoint": "https://northboundsupply.com/ucp/v1/pricing", "currency_default": "USD", "supports_tax_quote": true }, "checkout": { "supported": true, "endpoint": "https://northboundsupply.com/ucp/v1/checkout", "payment_methods": ["card", "wallet"], "guest_checkout": true }, "inventory": { "supported": true, "endpoint": "https://northboundsupply.com/ucp/v1/inventory", "realtime": true } }, "auth": { "type": "oauth2", "token_endpoint": "https://northboundsupply.com/ucp/oauth/token", "scopes": ["catalog:read", "checkout:write"] }, "policies": { "returns_url": "https://northboundsupply.com/returns", "privacy_url": "https://northboundsupply.com/privacy", "terms_url": "https://northboundsupply.com/terms" }, "contact": { "technical_email": "[email protected]" }, "last_updated": "2026-01-15T09:00:00Z" }

Now the field walkthrough. We are opinionated about which of these you cannot skip.

ucp_version: This declares the protocol version the manifest is written against, not your store’s version. Agents use it to decide which parsing rules apply. Omit it and strict agents treat the document as untrusted. Always include it.

merchant block: This is your identity. The `id` should be stable and unique; never regenerate it, because agents and downstream systems may cache it. The `domain` field must exactly match the domain serving the manifest. We have watched mismatches here (manifest served from `www`, domain declared as apex) cause agents to flag the document as spoofed.

capabilities: This is the heart of the file. Each capability is a named object with a `supported` boolean and an `endpoint`. The rule we enforce internally: if `supported` is `true`, that endpoint must return live, valid data today. Declaring a checkout capability you have not built is the fastest way to get an agent to start a transaction it cannot finish, which is a far worse outcome than not advertising it at all.

auth: If any of your endpoints require authentication, this block tells agents how to obtain a token. Guest, read-only catalog browsing often needs no auth, but checkout almost always does. Be explicit about scopes.

policies and contact: These feel like boilerplate and they are the fields merchants most often leave out, but agents increasingly use returns and privacy URLs to decide whether to transact at all. Treat them as trust signals, not legal afterthoughts.

last_updated: An ISO 8601 timestamp. Agents use it for cache invalidation. Stale timestamps on a manifest that actually changed cause agents to serve old capability data.

Your core-setup checklist:

  • Strict JSON only: Run the file through a parser, not your eyes; no trailing commas, no comments, no single quotes.
  • Every endpoint absolute: Use full `https://` URLs, never relative paths, because agents resolve from the manifest URL inconsistently.
  • Capabilities match reality: Set `supported: true` only where the endpoint is live and tested.
  • Identity consistent: Make `merchant.domain` match the serving domain character for character.
  • Timestamp current: Update `last_updated` every time the manifest changes, in UTC ISO 8601.

Implementation Steps: Deploying Your Manifest the Right Way

Here is the deployment sequence we run on every engagement, in order. Follow these numbered steps rather than improvising, because the order prevents the most expensive mistakes.

  1. Author the file locally and lint it. Write the manifest in your editor, then validate it with a JSON linter and a schema validator before it ever touches a server. We catch roughly a third of all manifest issues at this stage with zero production risk.
  2. Place it at the exact canonical path. Deploy the file so it resolves at `https://yourdomain.com/.well-known/ucp/manifest.json`. On static hosts this is a directory; on frameworks it may require a route or a public folder exception so the leading dot is not stripped.
  3. Set the correct headers. The response must be HTTP 200 with `Content-Type: application/json` and ideally `Cache-Control` set to something sane like `max-age=3600`. We have seen stores serve the file as `text/html` and watch strict agents reject it despite perfect JSON inside.
  4. Remove all redirects and auth from the manifest fetch itself. The manifest must be fetchable anonymously in a single request. A 301 to `www`, a login wall, or a Cloudflare challenge page in front of it will break discovery even when the underlying file is flawless.
  5. Confirm every declared endpoint resolves. Hit each capability endpoint directly and confirm it returns valid, live data. This is the step merchants skip, and it is the one that caused the six-week outage we opened with.
  6. Validate end to end with a checker. Run your live URL through an independent validator to confirm an external party sees what you think you deployed.
  7. Monitor the file as infrastructure. Add an uptime check on the manifest URL and an alert on content changes, because the file failing silently is the default failure mode, not the exception.

For platform specifics, our Shopify UCP integration guide and our WooCommerce UCP integration guide show the exact deployment mechanics per platform, which differ meaningfully in how they handle the `.well-known` path.

Implementation checklist:

  • Lint before deploy: Never push a manifest that has not passed a schema validator locally.
  • Headers correct: Serve 200, `application/json`, and a sane cache policy.
  • Single anonymous fetch: No redirects, no auth, no challenge pages on the manifest URL.
  • Endpoints tested: Every `supported: true` capability returns live data when hit directly.
  • External validation passed: Confirm with a third-party checker, not just your own browser.

How Do You Validate a UCP Manifest JSON Example Against the Spec?

Validation happens in three layers, and we treat skipping any of them as negligence. The reason the forum-copied manifest failed for six weeks is that the merchant validated exactly zero of them.

Layer one, syntax: Is it parseable JSON? This is the floor. A trailing comma, a smart quote pasted from a document, or a truncated file fails here. Use a strict parser; most editors have one built in, and `jq` on the command line is our go-to because it refuses malformed input outright.

Layer two, schema: Does it match the UCP manifest schema? Syntactically valid JSON can still be semantically wrong, for example a `capabilities` object missing required endpoints or a malformed timestamp. Schema validation catches the structural errors that syntax checking misses. We maintain internal schema tests that run in CI so a bad manifest can never merge.

Layer three, behavior: Do the declared capabilities actually work? This is the layer almost everyone ignores and the one that matters most. A manifest can pass layers one and two perfectly while every endpoint it points to returns a 404. This is exactly why we keep hammering the caveat around adoption numbers.

UCP Checker, which independently monitors 20,120+ storefronts, reports that roughly 81% pass full UCP validation, with 16,376 verified. We cite that figure carefully, because it skews heavily toward Shopify stores and, more importantly, a conformant manifest is not the same as an agent being able to complete a real checkout. We have personally validated manifests that passed every structural check and still could not process a single agent transaction because the checkout endpoint timed out under real load. Conformance is table stakes. Working is the goal.

Validation checklist:

  • Parse it: Confirm strict JSON parsing with `jq` or an equivalent strict parser.
  • Schema check it: Run it against the UCP manifest schema in CI, not manually.
  • Resolve every endpoint: Programmatically hit each declared capability and assert a 200 with valid data.
  • Simulate an agent: Run at least one full discovery-to-action flow the way an agent would.
  • Re-validate on every change: Treat the manifest like code; nothing ships without passing all three layers.

The TRUST Framework: Our Five-Step Method for a Manifest Agents Will Actually Use

Over dozens of implementations we distilled our approach into a framework we call TRUST, because the manifest’s real job is to earn an agent’s trust enough to transact. Each step has a clear outcome.

T, Target the canonical path. What this achieves: It guarantees discoverability by ensuring the manifest sits at the exact well-known URL agents construct from your domain, with no redirects or path rewrites in the way.

R, Reduce to real capabilities. What this achieves: It eliminates the worst failure class, advertised-but-broken endpoints, by declaring `supported: true` only for operations you have tested end to end under production conditions.

U, Unify identity and headers. What this achieves: It prevents spoofing rejections by making your `merchant.domain`, your serving domain, your TLS certificate, and your `Content-Type` header all agree with each other.

S, Stamp and version everything. What this achieves: It keeps agent caches honest by maintaining accurate `ucp_version`, `manifest_version`, and `last_updated` values so agents never act on stale capability data.

T, Test like an adversary. What this achieves: It surfaces silent failures before customers do by running automated, scheduled checks that fetch the manifest anonymously, validate all three layers, and alert the moment anything drifts.

We tell clients that if they only do one thing from this guide, it should be the final T. The entire opening disaster was a failure to test like an adversary.

A conformant manifest is a locked front door with no one checking whether it actually opens; the merchants who win in agentic commerce are the ones who test the door every single day.

Framework checklist:

  • Target: Manifest resolves at the canonical `.well-known/ucp/manifest.json` with no redirects.
  • Reduce: Only real, tested capabilities carry `supported: true`.
  • Unify: Domain, certificate, and content-type headers all agree.
  • Stamp: Version and timestamp fields are accurate and current.
  • Test: Scheduled adversarial checks alert on any silent drift.

Make Your Store Transactable by the Agents That Are Already Shopping

If you have gotten this far, you understand that a UCP manifest is not a checkbox, it is the interface between your revenue and an entirely new class of buyer. This is precisely what our Universal Commerce Protocol platform exists to handle: we deploy, validate, and continuously monitor your manifest and every capability endpoint behind it so your store stays transactable while agents evolve underneath you. Instead of copying a UCP manifest JSON example from a forum and hoping, you get infrastructure built by a team that fixes these failures for a living. If you run on Shopify or WooCommerce and want this handled correctly the first time, talk to our team and we will get your manifest live, validated, and monitored. You can also see the bigger picture of what we build at UCPhub.

Optimization: Tuning the Manifest for Real Agent Behavior

Once your manifest is valid and live, the next tier of work is optimization, and here the decisions are about agent experience rather than spec compliance. We approach this the way we would optimize an API, because that is what you are building.

Declare freshness honestly: The `updated_frequency` field on your catalog capability sets agent expectations. If you say `hourly` but only sync nightly, agents either over-poll (wasting your rate limit) or serve stale data (burning customer trust). Match the declared frequency to reality, and if your inventory moves fast, set `realtime: true` on inventory only if your endpoint genuinely supports it.

Scope auth tightly: Over-broad scopes make security teams nervous and can slow agent adoption. We default to read-only catalog and pricing without auth, and require auth only on `checkout:write`. The narrower and clearer your scopes, the faster an agent can transact without a human intervening.

Cache deliberately: A `Cache-Control: max-age=3600` on the manifest itself is a good default. The manifest changes rarely; the data behind the endpoints changes constantly. Cache the pointer document, not the live data. We have seen stores accidentally cache their pricing endpoint for an hour and ship an agent a stale sale price, which is both a trust and a liability problem.

Keep the manifest small: A lean manifest parses faster and fails less. Resist the urge to inline catalog data, policy prose, or marketing copy. Every field you add is a field that can break. The example above is close to our recommended ceiling for a manifest’s size.

This optimization mindset is the difference between a store that merely passes validation and one that converts agent traffic. Our analysis of agentic commerce conversion rates under UCP shows how much these seemingly small tuning decisions move the needle once agents are actually buying.

Optimization checklist:

  • Honest freshness: `updated_frequency` and `realtime` flags match your real sync cadence.
  • Minimal scopes: No auth on public reads; tight scopes on write operations.
  • Cache the pointer: Cache the manifest, never the live pricing or inventory data behind it.
  • Lean document: No inlined catalog or marketing content in the manifest.
  • Fast endpoints: Capability endpoints respond well under a second at expected agent concurrency.

Common Mistakes to Avoid

We maintain an internal tally of the failures we encounter most, and the pattern is remarkably consistent across platforms. If you avoid these, you are ahead of a large share of the market.

Wrong path, silently wrong: Placing the manifest at `/.well-known/manifest.json` instead of `/.well-known/ucp/manifest.json`, or at the site root. The file exists, it validates, and no agent ever finds it. We check this first on every audit because it is the most common single error.

The leading-dot deployment trap: Many build tools and static hosts strip or ignore directories that begin with a dot. The manifest looks deployed in your repo and returns 404 in production. Always verify the live URL, never trust that the file “should” be there.

Declaring capabilities you cannot honor: Setting `checkout.supported` to `true` before the checkout endpoint is built. This is worse than silence because it invites agents into transactions that fail at the last step, which agents remember and penalize.

Trailing commas and smart quotes: The classic. JSON is strict, and a manifest copied through a word processor or a chat window often picks up curly quotes or a trailing comma that breaks parsing entirely. This is the exact bug that cost the merchant in our introduction six weeks of invisibility.

Serving it as HTML: A wrong `Content-Type` header. The bytes are valid JSON, the header says `text/html`, and strict agents refuse it. Always confirm the header, not just the body.

Treating it as set-and-forget: A manifest is infrastructure, and infrastructure drifts. Platform updates, domain migrations, and certificate renewals all break manifests weeks after deployment. The merchants who treat it as a one-time task are the ones who call us in a panic later.

Confusing UCP with a custom integration: Teams sometimes hand-roll bespoke agent endpoints and skip the standardized manifest, assuming it is interchangeable. It is not, and we explain why point solutions do not scale in our comparison of UCP versus custom AI integrations and our UCP hub versus custom integration guide.

Mistakes-to-avoid checklist:

  • Verify the nested path: Confirm the `ucp` subdirectory in the live URL, not just locally.
  • Check the dot survives deploy: Confirm the leading-dot directory serves in production.
  • Match capabilities to reality: No `true` flags on endpoints you have not tested.
  • Lint for strict JSON: Catch commas and smart quotes before deploy.
  • Confirm the content type: Verify `application/json` on the live response.
  • Monitor continuously: Alert on manifest downtime and content drift.

Advanced Tips for Multi-Store, Multi-Region, and High-Volume Setups

Once the basics are solid, larger merchants hit a second set of challenges that the simple example does not cover. These are the patterns we deploy for stores operating at scale.

Multi-region manifests: If you serve different catalogs, currencies, or legal terms by region, do not try to encode everything in one manifest. Serve region-appropriate capability endpoints and use your `pricing.currency_default` and policy URLs to reflect the region the manifest represents. For truly separate storefronts, each canonical domain gets its own manifest.

Versioning strategy for evolution: As the protocol advances, you will need to support more than one `ucp_version` during transition windows. We keep the manifest pinned to the version our endpoints fully honor and only bump it once every declared capability is validated against the new version. Never advertise a version your backend cannot fully speak. The deeper mechanics of how these pieces fit together are covered in our UCP technical architecture deep dive.

Rate limiting and agent fairness: At volume, agents can hammer your endpoints. Declare sensible expectations and implement rate limiting on the endpoints, not the manifest. The manifest stays always-available; the data endpoints enforce fair use with clear 429 responses so well-behaved agents back off gracefully.

Observability as a first-class concern: We instrument every capability endpoint with per-agent metrics so we can see which agents are discovering, browsing, and transacting. When discovery drops, we know within minutes rather than six weeks. This observability is the operational difference between treating agentic commerce as a live revenue channel and treating it as a science project.

Staying ahead of the standard: The agentic landscape is not static, and there is genuine competition among standards. We keep a close read on where things are heading in our analyses of UCP versus ACP and which standard will rule the agentic web and the future of UCP and agentic commerce. Building your manifest on a standard with momentum matters as much as building it correctly.

Advanced checklist:

  • Region-aware endpoints: Serve region-correct capabilities and policies, one manifest per canonical domain.
  • Conservative versioning: Pin to the version your backend fully honors; bump only after validation.
  • Endpoint rate limits: Protect data endpoints with clear 429s; keep the manifest always up.
  • Per-agent observability: Instrument discovery and transaction metrics to catch drops fast.
  • Standard awareness: Track protocol direction so your investment compounds rather than strands.

Measuring Success: KPIs and Your 30, 60, and 90 Day Outcomes

A manifest you cannot measure is a manifest you are guessing about. Here is how we define success over the first quarter after deployment, formatted as the running checklist we hand clients.

  • Day 30, discovery confirmed: Independent validation passes all three layers, the manifest returns 200 on every scheduled check with zero downtime, and you can see at least one real agent fetching it in your logs.
  • Day 30, endpoints green: Every `supported: true` capability returns valid live data on automated hourly checks, with sub-second median response times.
  • Day 60, first transactions: You have recorded genuine agent-initiated actions beyond discovery, meaning catalog reads converting into at least a handful of real checkouts, not just manifest fetches.
  • Day 60, zero silent failures: No capability has failed undetected for more than the length of one monitoring interval, proving your adversarial testing works.
  • Day 90, conversion baseline: You have a measurable agent conversion rate to optimize against, and you know your busiest agents and your most-browsed endpoints.
  • Day 90, operational maturity: Manifest changes ship through CI with full three-layer validation, and a certificate renewal or platform update no longer carries the risk of silent breakage.
  • Ongoing, trend not snapshot: You are watching the direction of agent discovery and transaction volume week over week, so the next six-week outage is impossible because you would catch it in one interval.

If your KPIs stall at discovery and never reach transactions, the problem is almost never the manifest syntax; it is a broken or slow capability endpoint behind a perfectly valid manifest. That distinction is the whole point of this guide.

If you are just getting started, prioritize correctness over completeness: get a minimal, valid manifest at the exact canonical path with one or two genuinely working capabilities, validated through all three layers, before you add anything fancy. A small manifest that works beats a comprehensive one that silently fails. If instead you are auditing an existing manifest, start at the opposite end and test like an adversary first: fetch the live URL anonymously, check the response headers, then hit every declared endpoint and confirm it returns real data, because that is where the hidden rot almost always is. For a gentler conceptual on-ramp before you dive into the JSON, our UCP for beginners guide sets the context well.

Next Steps:

  • Validate your live URL today: Fetch `https://yourdomain.com/.well-known/ucp/manifest.json` anonymously and confirm a 200 with `application/json`.
  • Test every endpoint, not just the file: Hit each declared capability and confirm it returns live data under real conditions.
  • Get expert eyes on it: If anything above is uncertain, contact our team and we will audit, deploy, and monitor your manifest end to end.

Frequently Asked Questions

Can you provide a UCP manifest JSON example?

Yes, and the complete, working UCP manifest JSON example earlier in this guide is the exact starting shape we use on real implementations. It includes the `ucp_version`, a `merchant` identity block, a `capabilities` object declaring catalog, pricing, checkout, and inventory endpoints, an `auth` block, policy URLs, and a `last_updated` timestamp.

The important thing to understand is that the example is a template, not a copy-paste answer. Every endpoint URL, merchant ID, domain, and supported flag must be changed to reflect your actual store and your actual, tested backend. The single most dangerous thing you can do is copy a UCP manifest JSON example verbatim and deploy it, because then you are advertising someone else’s endpoints or, worse, declaring capabilities you have never tested.

Use the example to understand the structure and the required fields, then build your own against your real backend and validate it through all three layers: syntax, schema, and behavior. That sequence is what turns an example into a manifest that actually works.

What does a valid UCP manifest look like?

A valid UCP manifest is strict, parseable JSON served at `https://yourdomain.com/.well-known/ucp/manifest.json` with an HTTP 200 status and a `Content-Type` of `application/json`. It declares a protocol version, a consistent merchant identity whose domain matches the serving domain, and a `capabilities` object where every endpoint marked supported actually resolves and returns live data.

Validity operates on three levels. Syntactically it must parse with no trailing commas, no comments, and all keys double-quoted. Structurally it must match the UCP manifest schema, meaning required fields are present and correctly typed. Behaviorally, and this is the level most people miss, every capability it advertises must genuinely work when an agent calls it.

We stress this because validity on paper and validity in practice diverge constantly. UCP Checker, which monitors 20,120+ storefronts, reports roughly 81% pass full validation, yet a passing manifest is not the same as an agent being able to complete a real checkout. A manifest that validates perfectly but points to a dead checkout endpoint is, for a shopper, not valid at all.

Where can I find UCP manifest examples?

The best examples come from live, validated stores and from implementation teams that build these for a living, which is why we put a complete working example directly in this guide rather than sending you hunting. We strongly advise against grabbing examples from unvetted forum posts or chat transcripts, because those are the exact source of the trailing-comma and smart-quote failures that silently break discovery.

If you want more context around the structure, our UCP technical architecture deep dive explains how the manifest relates to the capability endpoints behind it, and our platform-specific guides for Shopify and WooCommerce show how deployment differs by platform.

Wherever you find an example, treat it as a structural reference only and validate your own version before it goes live. An example’s job is to teach you the shape; your validation pipeline’s job is to confirm your specific file works.

Does my UCP manifest need authentication to be valid?

The manifest itself must never require authentication. Agents discover it with a single anonymous request, so any login wall, auth challenge, or token requirement on the manifest URL breaks discovery entirely. The manifest is a public document by design.

Authentication applies to the capability endpoints behind the manifest, not the manifest file. You declare how agents authenticate in the `auth` block, and in our deployments we typically leave read-only catalog and pricing open while requiring auth only for write operations like checkout. This keeps the common browsing path frictionless while protecting the operations that need protecting.

So the answer is a clear no for the manifest and a context-dependent yes for the endpoints. Getting this split wrong, by either locking the manifest or exposing checkout with no auth, is a mistake we correct regularly.

How often should I update my UCP manifest?

The manifest itself should change rarely, because it is a pointer document, not a data feed. You update it when your capabilities change, when you add or remove a supported operation, when endpoints move, or when you adopt a new protocol version. Each time you do, you must update the `last_updated` timestamp so agent caches invalidate correctly.

The data behind the endpoints, by contrast, changes constantly, and that is exactly why the separation matters. Your catalog and inventory can update every minute without you ever touching the manifest, as long as the declared `updated_frequency` honestly reflects your real sync cadence.

What you should do continuously, as opposed to update, is monitor. We run scheduled checks on the manifest around the clock so any drift, a certificate expiry, a platform update that strips the path, a header that changes, surfaces within one monitoring interval rather than six weeks later.

What happens if my UCP manifest is invalid or missing?

If your manifest is missing or invalid, your store becomes effectively invisible to AI shopping agents. They construct the well-known URL, fetch it, fail to parse or locate it, and move on, usually with no visible error on your side. This is the silent failure mode that makes invalid manifests so dangerous, because nothing alarms until you notice a revenue channel that never materialized.

The severity scales with how agentic buying grows. Today a broken manifest might cost a modest segment of traffic; as agents become a larger share of shoppers, as we explore in our piece on a UCP-first commerce model where agents are the primary shoppers, the cost of invisibility compounds.

The fix is straightforward but requires discipline: deploy a valid manifest at the canonical path, validate it through all three layers, and monitor it as the piece of revenue infrastructure it actually is. That is the entire difference between the merchant who loses six weeks silently and the one who never loses a day.

Is UCP actually live, and should I build my manifest now?

UCP is live, and we cover the launch in detail in our UCP release date and launch guide. The protocol is no longer theoretical, agents are already fetching manifests and attempting transactions, which is precisely why the silent-failure risk is real today rather than hypothetical.

Our strong recommendation is to build now, correctly and conservatively, rather than wait. Early, well-instrumented manifests give you a measurable agent channel and a head start on optimization, while the stores that delay are starting from zero once agent traffic becomes significant. Building early is low cost; catching up late is not.

That said, build correctly from day one. A rushed, unvalidated manifest is worse than none because it fails silently. Start minimal, validate rigorously, monitor continuously, and expand as your confidence and your endpoints mature.

Sources

ready when you are

Make your store
UCP-native today.

install in < 5 min ยท no credit card ยท cancel anytime