Implementing OpenAI Product Feed & ACP (Agentic Commerce Protocol) for AI Shopping Agents
How to build machine-readable OpenAI Product Feeds and implement the Agentic Commerce Protocol (ACP/UCP) for zero-click AI assistant purchases.
Executive Summary
Technical implementation guide for OpenAI Product Feeds and Agentic Commerce Protocols (ACP/UCP): structuring machine-readable JSONL catalogs for autonomous AI shopping and booking agents.
The mechanics of online commerce are undergoing a historic transformation.
Consumers are increasingly delegating purchasing decisions—from selecting enterprise SaaS subscriptions and booking architectural consultations to purchasing physical hardware—directly to **Autonomous AI Assistants** running on ChatGPT, Claude, and Gemini.
When a user instructs their assistant: *"Find me the top-rated AI systems architect who specializes in multi-agent swarms and book a 1-hour consultation for tomorrow afternoon"*, the AI agent does not navigate visual web pages with a browser.
Instead, the agent executes structured discovery requests against **Machine-Readable Product Feeds** and engages in **Agentic Commerce Protocols (ACP / UCP)** to compare capabilities, verify pricing, and prepare checkout payloads.
┌────────────────────────────────────────────────────────────────────────┐
│ THE AGENTIC COMMERCE (ACP/UCP) PIPELINE │
│ │
│ User Intent ──► ChatGPT / Claude Assistant │
│ │ │
│ ├──► 1. Query Discovery Feed (/api/discovery/services)│
│ ├──► 2. Evaluate Capabilities, Pricing & Availability │
│ ├──► 3. Perform Cryptographic ACP Handshake │
│ └──► 4. Render 1-Click Interactive Purchase Card ✅ │
└────────────────────────────────────────────────────────────────────────┘If your business only presents its service catalog through traditional HTML web pages, AI shopping agents cannot reliably parse your pricing, check availability, or execute orders on behalf of users.
This tactical cluster guide breaks down the complete engineering implementation of the **OpenAI Product Feed Specification** and the **Universal Commerce Protocol (UCP)** for modern web platforms.
1. The OpenAI Product Feed Specification
OpenAI's commerce specification requires structured catalog data exposed either via continuous JSONL feeds or dynamic API endpoints.
Each service or product record must provide deterministic metadata attributes that enable the LLM's tool-calling router to match user prompts with mathematical precision:
// api/discovery/services.json (UCP / OpenAI Compatible Catalog)
{
"version": "ucp-2026-01",
"provider": {
"name": "Hamid Ayub Systems Consulting",
"url": "https://hamidayub.com",
"entity_id": "https://hamidayub.com/#author",
"currency": "USD"
},
"items": [
{
"id": "srv_systems_architecture_consult",
"title": "Principal Systems Architecture & Multi-Agent Swarm Consultation",
"description": "1-on-1 technical advisory session on distributed multi-agent state machines, zero-downtime database migrations, and low-latency voice AI.",
"category": "Technology > Software Architecture > Advisory",
"price": {
"amount": 750.00,
"currency": "USD",
"type": "fixed"
},
"availability": {
"status": "in_stock",
"lead_time_days": 1
},
"target_queries": [
"hire principal systems architect",
"multi agent swarm consulting",
"enterprise ai architecture review"
],
"actions": {
"checkout_url": "https://hamidayub.com/booking?service=srv_systems_architecture_consult",
"api_endpoint": "https://hamidayub.com/api/commerce/reserve"
}
}
]
}2. Implementing the Discovery Feed in Next.js 16
To serve real-time pricing and availability without database overhead, we build a statically revalidated Edge Route in Next.js:
// app/api/discovery/services.json/route.ts
import { NextResponse } from 'next/server';
export const runtime = 'edge';
export const revalidate = 3600; // 1 hour edge cache
export async function GET() {
const catalog = {
version: 'ucp-2026-01',
provider: {
name: 'Hamid Ayub Systems Consulting',
url: 'https://hamidayub.com',
entity_id: 'https://hamidayub.com/#author',
},
items: [
{
id: 'srv_arch_advisory',
title: 'Principal Systems Architecture Advisory',
description: 'Comprehensive technical review of distributed systems, AI state machines, and database scalability.',
price: { amount: 750.00, currency: 'USD', type: 'fixed' },
availability: { status: 'in_stock', lead_time_days: 1 },
actions: {
checkout_url: 'https://hamidayub.com/booking',
},
},
{
id: 'srv_seo_audit',
title: 'Agentic SEO & AI Search Grounding Review',
description: 'Audit of llms.txt, Schema.org Knowledge Graphs, and Perplexity citation readiness.',
price: { amount: 500.00, currency: 'USD', type: 'fixed' },
availability: { status: 'in_stock', lead_time_days: 2 },
actions: {
checkout_url: 'https://hamidayub.com/booking?service=seo',
},
},
],
};
return new NextResponse(JSON.stringify(catalog, null, 2), {
headers: {
'Content-Type': 'application/json; charset=utf-8',
'Cache-Control': 'public, max-age=3600, s-maxage=3600',
},
});
}3. The ACP Handshake: Securing AI Autonomous Purchases
When an autonomous agent initiates an order, security and idempotency are paramount.
The **Agentic Commerce Protocol (ACP)** enforces a three-step cryptographic handshake:
┌────────────────────────────────────────────────────────────────────────┐
│ CRYPTOGRAPHIC ACP PURCHASE HANDSHAKE │
│ │
│ 1. Agent Generates Intent Nonce: │
│ POST /api/commerce/intent ──► Returns Session Token & HMAC Nonce │
│ │
│ 2. User Approves In-Chat Authorization: │
│ User confirms biometric / passkey confirmation in ChatGPT UI │
│ │
│ 3. Agent Executes Atomic Settlement: │
│ POST /api/commerce/execute (with Idempotency-Key & Signature) │
│ ──► Returns Confirmed Order ID & Calendar Invite ✅ │
└────────────────────────────────────────────────────────────────────────┘Production Idempotency Implementation in TypeScript
// app/api/commerce/reserve/route.ts
import { NextResponse } from 'next/server';
import { z } from 'zod';
const ReservationSchema = z.object({
serviceId: z.string(),
clientEmail: z.string().email(),
preferredTimestamp: z.string().datetime(),
idempotencyKey: z.string().uuid(),
});
export async function POST(request: Request) {
const body = await request.json();
const result = ReservationSchema.safeParse(body);
if (!result.success) {
return NextResponse.json({ error: 'Invalid ACP payload', details: result.error.errors }, { status: 400 });
}
const { serviceId, clientEmail, preferredTimestamp, idempotencyKey } = result.data;
// In production: Check Redis for idempotencyKey to prevent duplicate billing!
return NextResponse.json({
status: 'confirmed',
bookingId: `bk_${idempotencyKey.slice(0, 8)}`,
serviceId,
clientEmail,
scheduledAt: preferredTimestamp,
calendarInviteUrl: `https://hamidayub.com/cal/invite/${idempotencyKey}`,
});
}4. Real-Time Inventory & Price Sync via Webhook Invalidation
Because AI shopping assistants act on live real-time constraints, stale pricing or booked-out calendar slots create critical failure points in the user journey.
To eliminate latency drift, we connect our CMS and scheduling backend (e.g. Cal.com or Stripe) to an automated **Edge Cache Purge Webhook**:
// app/api/webhooks/revalidate-feed/route.ts
import { NextResponse } from 'next/server';
import { revalidateTag } from 'next/cache';
export async function POST(req: Request) {
const authHeader = req.headers.get('Authorization');
if (authHeader !== `Bearer ${process.env.FEED_WEBHOOK_SECRET}`) {
return NextResponse.json({ error: 'Unauthorized webhook trigger' }, { status: 401 });
}
// Purge edge cache across all global CDN nodes in under 200ms
revalidateTag('acp-service-feed');
return NextResponse.json({
status: 'revalidated',
timestamp: new Date().toISOString(),
});
}┌────────────────────────────────────────────────────────────────────────┐
│ REAL-TIME FEED INVALIDATION FLOW │
│ │
│ Service Booked / Price Updated ──► Stripe / Cal.com Webhook │
│ │ │
│ ▼ │
│ Next.js Edge Revalidation (/api/webhooks) │
│ │ │
│ ▼ │
│ Instant Global CDN Purge (<200ms) │
│ │ │
│ AI Assistant always receives 100% accurate, live pricing! ✅ │
└────────────────────────────────────────────────────────────────────────┘5. Comparing Traditional Web Feeds vs Agentic Protocols
6. Production Implementation Checklist
To enable autonomous commerce for your platform:
- **Serve `/api/discovery/services.json`:** Expose machine-readable service descriptions and pricing.
- **Link Feed from `llms.txt`:** Add explicit catalog links in your root `llms.txt` file.
- **Enforce Strict Idempotency:** Use UUIDv4 headers to eliminate duplicate charges in automated tool loops.
- **Implement Passkey / Biometric Handshakes:** Keep users in control of final payment authorization.
- **Configure Real-Time Webhook Revalidation:** Guarantee pricing changes update across edge nodes in sub-second intervals.
- **Log Agentic Conversion Metrics:** Segment analytics to track revenue generated via ChatGPT autonomous shopping vs direct web visitors.
- **Conduct Automated Schema Fuzzing:** Test discovery JSON payloads against Zod validation schemas during every deployment.
To learn how to optimize your overall AI search and discovery architecture, read our [Master Pillar Guide on Agentic SEO & AI Search Grounding](/guides/agentic-seo-ai-search-grounding-mastery) or schedule an [Agentic SEO & Commerce Consultation](/services/seo).
Also in this series
Dynamic Metadata & Edge OpenGraph Generation for Autonomous AI Crawler Discovery
How to generate dynamic OpenGraph cards and multi-modal metadata at the Edge in 15ms for instant social preview and AI search bot ingestion.
Reverse Engineering Perplexity: How AI Search Engines Rank and Ground Sources
A deep reverse engineering of Perplexity AI's citation algorithms, cross-encoder re-rankers, and retrieval windows.