# Agentic Commerce Readiness Audit: ChatGPT, UCP, AI Agents (`reliable_tools/agentic-commerce-readiness-audit`) Actor

Check if AI shopping agents can find, understand and buy from your Shopify store: UCP profile, ChatGPT product feed fields, schema.org Product markup, AI crawler access, llms.txt and return/shipping policies. Scores per protocol plus ready fixes.

- **URL**: https://apify.com/reliable_tools/agentic-commerce-readiness-audit.md
- **Developed by:** [Reliable Tools](https://apify.com/reliable_tools) (community)
- **Categories:** E-commerce, SEO tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $34.00 / 1,000 store auditeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Agentic Commerce Readiness Audit: can AI shopping agents buy from your store?

This agentic commerce readiness audit checks whether AI shopping agents can find and buy from your store. Agents in ChatGPT, Google and other assistants read your product feed, your structured data, your robots.txt and a few machine-readable files, and if something is missing they pick another store. Give it store URLs and get a score per protocol, every failed rule with the exact fix, and fixes you can paste in: a ChatGPT product feed row and Product JSON-LD built from your own product data, a return-policy snippet, an llms.txt draft and robots.txt lines.

Not affiliated with or endorsed by OpenAI, Google or Shopify. ChatGPT, Google and Shopify are trademarks of their owners.

### Who it's for

- Shopify brands that want to show up in ChatGPT shopping and Google's AI results and don't know where they stand.
- E-commerce, SEO and GEO agencies that need an audit they can run across many client stores and hand over.
- Shopify app and theme developers who want to see which stores are missing agent-ready data.
- Anyone pitching agentic commerce work who needs hard evidence from a real store, not a slide.

### What it checks

52 fixed rules, each with a rule ID, a severity and a fix text. The rules follow the current public specs: the
OpenAI product feed spec for ChatGPT, the Universal Commerce Protocol (UCP) release 2026-08-25, Shopify's agent
documentation, and Google's merchant listing structured data guidelines.

| Area | What we look at |
|---|---|
| UCP profile | Is `/.well-known/ucp` published, without redirect, with the required members, an HTTPS MCP or REST endpoint, catalog search and checkout, cache headers and the current protocol version |
| ChatGPT feed fields | Can the 9 required feed fields be filled from your public data: title (max 150 characters), description (max 5,000), brand, image, price, availability. Plus GTIN with check digit, category, variant option names, weight |
| schema.org markup | Product JSON-LD in the page HTML, Offer with price and currency, availability, image, brand, GTIN or MPN, description, return policy, shipping details. We also check that the markup price and stock match the real store values |
| AI crawler access | Whether robots.txt lets OAI-SearchBot (ChatGPT search), Googlebot, PerplexityBot, Claude-SearchBot and Bingbot read product pages. Training bots (GPTBot, Google-Extended, ClaudeBot and others) are reported but not scored, since blocking them is your choice |
| Agent files | llms.txt present and pointing to policies or the commerce endpoint, sitemap declared |
| Policies | Return, shipping, terms and privacy pages exist (ChatGPT checkout needs terms and privacy). AI checks whether the return window, return costs, delivery times and shipping costs are stated clearly, and quotes the sentence it found |
| Product content | AI checks whether each description lets an agent decide what the product is, its size or fit, and its material or format, again with the quoted sentence |
| Images | Alt text on every image, alt text that isn't a file name or a copy of the title, main image of at least 50,000 pixels, more than one image |

The quoted evidence is always an exact sentence from your store, never generated text. Pass and fail thresholds are
fixed in code: a semantic check passes at 0.7 or higher, fails at 0.3 or lower, and anything in between comes back as
`warn` so a person can take a look.

### What you get

The dataset has two kinds of rows, marked by `type`.

**Store rows** (`type: "store"`):

- `scores`: 0 to 100 for `openai_acp`, `google_ucp`, `schema_org` and `ai_access`, plus `overall`
- `prioritizedFixes`: failed rules ranked by severity and by how many sampled products they affect
- `ucp`: profile version, transports, MCP endpoint, capabilities and payment handlers
- `aiCrawlers`, `policyUrls`, `policyFacts` (return days, whether returns are accepted) and `policyEvidence` with quotes
- `fixes`: generated `organizationJsonLd`, `llmsTxt` and `robotsTxtAdditions` where needed

**Product rows** (`type: "product"`):

- `scores` per protocol, `failedRules` with fix text, `evidence` for the AI checks
- `fixes.feedRow`: a ChatGPT product feed row built from the product, plus `missingRequired`
- `fixes.productJsonLd`: a complete Product JSON-LD block with one Offer per variant, added when the markup fails

Use the **Stores** and **Products** views in the Output tab, or filter on `type` in your export.

### How to run it

1. Paste store URLs or domains into **Store URLs or domains**, for example `allbirds.com`.
2. Set **Products to check per store**. The default is 10. Product pages are read one at a time with a short pause,
   so 10 products take about 20 to 30 seconds per store.
3. Leave **AI content checks** on to get the description and policy checks with quotes. They cost nothing extra.
4. Start the run and export the results as JSON, CSV or Excel, or pull them through the API.

Shopify stores get the full audit. Other platforms get the store-level checks: UCP profile, robots.txt, llms.txt,
policy pages found in the footer and homepage markup.

### Example output

From a real run on allbirds.com on 29 October 2026, shortened:

```json
{
  "type": "store",
  "store": "allbirds.com",
  "shopName": "Allbirds",
  "scores": { "openai_acp": 92, "google_ucp": 90, "schema_org": 80, "ai_access": 100, "overall": 90 },
  "productsChecked": 10,
  "ucp": { "version": "2026-08-25", "transports": ["embedded", "mcp"],
           "endpoint": "https://weareallbirds.myshopify.com/api/ucp/mcp" },
  "policyEvidence": {
    "POL-05": { "status": "pass", "quote": "Our standard return policy is 30 days." },
    "POL-06": { "status": "pass", "quote": "Return Shipping: Customers are responsible for return shipping charges." },
    "POL-08": { "status": "warn", "detail": "confidence 0.46" }
  },
  "prioritizedFixes": [
    { "rank": 1, "ruleId": "AI-01", "severity": "high", "affectedProducts": "10 of 10",
      "title": "Description lets an agent decide (what it is plus key specs)" },
    { "rank": 2, "ruleId": "ORG-01", "severity": "medium", "scope": "store",
      "title": "Return policy is published as structured data (MerchantReturnPolicy)" },
    { "rank": 3, "ruleId": "FD-02", "severity": "critical", "affectedProducts": "3 of 10",
      "title": "Plain-text description present (40 to 5,000 characters)" }
  ],
  "fixes": {
    "organizationJsonLd": {
      "@context": "https://schema.org", "@type": "Organization", "name": "Allbirds",
      "hasMerchantReturnPolicy": { "@type": "MerchantReturnPolicy", "applicableCountry": ["US"],
        "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow", "merchantReturnDays": 30 }
    }
  }
}
```

A product row from the same run:

```json
{
  "type": "product",
  "title": "Women's Allbirds Flip Flop - Dusty Pink",
  "scores": { "openai_acp": 91, "google_ucp": 88, "schema_org": 82, "overall": 87 },
  "failedRules": [
    { "ruleId": "SD-06", "detail": "barcode exists in the store but is not in the markup" },
    { "ruleId": "IMG-01", "detail": "0/5 images have alt text" },
    { "ruleId": "AI-03", "detail": "confidence 0.04",
      "fix": "State what it is made of, or for digital products the file format and what the buyer receives." }
  ],
  "fixes": {
    "feedRow": {
      "row": { "item_id": "42146889039952", "brand": "Allbirds", "availability": "out_of_stock",
               "price": "50.00 USD", "gtin": "196942293089", "variant_dict": { "Size": "5" } },
      "missingRequired": []
    }
  }
}
```

### How to use the agentic commerce readiness audit via API

You can run the agentic commerce readiness audit in the Apify Console, or call it from your own code through the Apify API. The **API** tab of this Actor has ready-to-copy examples for the JavaScript and Python API clients, the Apify CLI, plain HTTP and the OpenAPI definition. To use it from an AI assistant or agent, connect the Apify MCP server and add this Actor as a tool.

Send the same JSON input you would fill in the form, for example a list of store URLs and the number of products to check, start a run, and read the results from the run's default dataset as JSON, CSV or Excel. You can also schedule runs in Apify.

### Pricing

Pay per event, no subscription.

| Event | Price | When |
|---|---|---|
| Store audited | $0.02 | Once per store that loads. Stores that can't be loaded are free |
| Product checked | $0.004 | Once per product whose page was read. Products we couldn't read are free |
| Actor start | $0.00005 | Once per run |

A store with 10 products costs about $0.06. The AI content checks are included.

### FAQ

**Is this legal?** The Actor only makes public GET requests to pages any visitor can open: the homepage, the public
product catalog, product pages, policy pages, robots.txt, llms.txt and the UCP profile. It identifies itself with its
own user agent, follows robots.txt for its own requests, and backs off when a store rate-limits it. It never logs in,
adds to cart, calls checkout or sends anything to the store's MCP endpoint. No personal data is collected. Policy
texts and product data from the store are sent to our AI processing provider in the USA for the content checks.

**Does a high score mean ChatGPT will show my products?** No. Being listed in ChatGPT shopping or Instant Checkout
also needs a merchant application with OpenAI, and Google decides on its own what it shows. The audit tells you
whether your public data meets the published specs, so nothing on your side blocks you.

**Why do some Shopify stores have no Product markup?** Some themes or apps add JSON-LD with JavaScript after the page
loads, or remove it. Most agents read the HTML without running JavaScript, so we score what is in the HTML.

**Why does a product show `unknown` for some rules?** The store rate-limited our requests for that page, or robots.txt
blocks our bot. Those products are not charged.

**Can I audit more than 10 products?** Yes, up to 100 per store. Larger samples take longer because we read product
pages one at a time to stay polite.

**What is agentic commerce?** Shoppers ask ChatGPT, Google and other assistants to find and buy products for them. Those agents read your product feed, structured data, robots.txt and a few machine-readable files instead of browsing like a person.

**What does the audit check for ChatGPT shopping?** Whether the required fields of the OpenAI product feed spec can be filled from your public data, whether your terms and privacy pages exist, and whether robots.txt lets OAI-SearchBot read product pages. You also get a ready-made feed row per product.

**Does it check Shopify MCP and UCP support?** Yes. It checks whether `/.well-known/ucp` is published with an HTTPS MCP or REST endpoint, catalog search, checkout and the current protocol version. It never sends anything to the store's MCP endpoint.

**Something looks wrong?** Open an issue on the Issues tab with the store and rule ID and we'll look at it.

### About Reliable Tools

This Actor is made by [Reliable Tools](https://apify.com/reliable_tools). We build data tools that return clean
results plus AI checks with a confidence score, so you can filter and act on the results straight away. Our focus is
e-commerce, product sourcing and compliance. You can find our other Actors on our
[profile page](https://apify.com/reliable_tools).

# Actor input Schema

## `stores` (type: `array`):

Stores to audit, e.g. allbirds.com or https://www.yourshop.com. Shopify stores get the full audit including products. Other platforms get the store-level checks (UCP profile, robots.txt, llms.txt, policies, homepage markup).

## `maxProductsPerStore` (type: `integer`):

How many products to sample from the public catalog. Each product page is read one at a time with a pause, so 10 products take about 30 seconds per store. 0 = store-level checks only.

## `semanticChecks` (type: `boolean`):

Checks whether each description lets a shopping agent decide (what it is, size or fit, material or format) and whether return and shipping terms are clearly stated, with the exact sentence quoted as evidence. No extra charge.

## Actor input object example

```json
{
  "stores": [
    "rosyspatterns.com",
    "allbirds.com"
  ],
  "maxProductsPerStore": 3,
  "semanticChecks": true
}
```

# Actor output Schema

## `stores` (type: `string`):

Dataset view with one row per audited store.

## `products` (type: `string`):

Dataset view with one row per checked product.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "stores": [
        "rosyspatterns.com",
        "allbirds.com"
    ],
    "maxProductsPerStore": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("reliable_tools/agentic-commerce-readiness-audit").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "stores": [
        "rosyspatterns.com",
        "allbirds.com",
    ],
    "maxProductsPerStore": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("reliable_tools/agentic-commerce-readiness-audit").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "stores": [
    "rosyspatterns.com",
    "allbirds.com"
  ],
  "maxProductsPerStore": 3
}' |
apify call reliable_tools/agentic-commerce-readiness-audit --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,reliable_tools/agentic-commerce-readiness-audit"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/eePo0U6zHaNx1cuYv/builds/cRis2P28pzw9h6yJB/openapi.json