# Shopify Product Feed Scraper — ChatGPT Shopping & UCP Export (`george.the.developer/shopify-agentic-commerce-product-feed`) Actor

Shopify product feed scraper and validator: export any public Shopify store as an agent-ready feed — normalized products with variants, price, availability and GTINs, validated against the OpenAI product feed spec and Google UCP attributes, with fix-it errors and free drift monitoring.

- **URL**: https://apify.com/george.the.developer/shopify-agentic-commerce-product-feed.md
- **Developed by:** [George Kioko](https://apify.com/george.the.developer) (community)
- **Categories:** E-commerce, AI, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Shopify Product Scraper — ChatGPT Shopping & Google UCP Feed Export

Turn any public Shopify store into an **agent-ready product feed**. This Shopify product scraper extracts the full catalog as structured JSON, validates every product against the **OpenAI product feed specification** and **Google UCP** catalog attributes, tells you exactly what to fix, and monitors price/stock/feed drift on a schedule.

```
storeUrl ──► catalog extract ──► normalize ──► validate against
             (products.json,      1 record/     OpenAI feed spec +
             collection JSON,     product,      UCP attributes
             sitemap, JSON-LD)    variants      │
                                  nested        ▼
                     free drift ◄── snapshot ◄── fix-it errors per product
                     monitoring     (persists)   + store readiness score
```

**You are only charged for agent-ready products** — records complete enough to be feed-eligible (canonical URL, title, price + currency, availability). Partial extractions are delivered free, with the errors that explain why. Typical scrapers charge up to $0.018/product for extraction alone; this actor charges $0.01 and includes the validation layer.

### Why agentic commerce, why now

- ChatGPT surfaces products from merchant feeds conforming to the **OpenAI Product Feed Specification** — product discovery in ChatGPT is feed-driven.
- Google's **UCP** (Universal Commerce Protocol, co-developed with Shopify) exposes storefronts to shopping agents; Shopify serves `/.well-known/ucp` manifests for millions of stores.
- If your catalog data is incomplete — missing GTINs, no availability, blocked AI crawlers — **agents can't recommend your products**. This actor shows you, per product, what's missing and how to fix it in Shopify admin.

### What one run does

1. **Extract** — walks a cost-ordered ladder of public endpoints: `/products.json` → collection JSON → product sitemap + per-product JSON → product-page JSON-LD (headless storefronts). No browser, no login, no credentials. Every record carries `sourceMethod`, `sourceUrl`, `capturedAt` as its evidence trail.
2. **Validate** — checks each product against the OpenAI product feed required attributes (id, title, description, link, image\_link, price, currency, availability, brand, GTIN/MPN) and UCP catalog attributes. Every violation names the **field**, the **rule**, the **evidence**, and the **remediation** ("add a barcode in Shopify admin → variant").
3. **Audit the store surface** — is `GPTBot` / `OAI-SearchBot` / `ChatGPT-User` allowed in robots.txt? Is a UCP manifest present at `/.well-known/ucp`? One free `store-summary` row scores overall readiness 0–100.
4. **Monitor (free)** — with `monitoring` on, each run diffs against the previous snapshot under the same `monitorId`: new/removed products, price changes, new and resolved feed issues. Snapshots persist in a named key-value store in **your** account, so history survives Apify's 31-day dataset retention.

### Output

One dataset, four record types (`recordType` field):

- `product` — normalized record with nested variants, identifiers, images, plus `agentReady` and `validationErrors[]`
- `store-summary` — free: readiness score, AI-bot robots policy, UCP manifest, top issues ranked by severity × frequency
- `diff-summary` — free: drift vs the previous monitored run
- `usage` — free: why a run couldn't proceed (never charged)

```json
{
  "recordType": "product",
  "agentReady": true,
  "billable": true,
  "title": "Death Wish Coffee — Dark Roast",
  "url": "https://www.deathwishcoffee.com/products/dark-roast",
  "price": "21.99", "currency": "USD", "availability": true,
  "brand": "Death Wish Coffee", "gtin": "859277000101", "mpn": "DWC-DR-1LB",
  "variants": [{ "sku": "DWC-DR-1LB", "price": "21.99", "available": true }],
  "validationErrors": [],
  "sourceMethod": "products-json",
  "capturedAt": "2026-08-03T12:00:00.000Z"
}
```

### Pricing — honest by construction

| Event | Price | Never-charged rule |
|---|---:|---|
| Actor start | $0.05 | — |
| Agent-ready product | $0.01 | Products below the confidence bar are delivered **free** with their validation errors. Failed runs, usage errors, summaries and diffs are always free. |

The confidence bar: resolved canonical URL + title + at least one variant with price and currency + availability. We don't charge for products we couldn't fully extract.

### For AI agents & developers

Run via API and consume the dataset as JSON — ideal input for agentic commerce pipelines, feed generators, and catalog QA:

```bash
curl -s -X POST "https://api.apify.com/v2/acts/<ACTOR_ID>/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"storeUrl": "https://yourstore.com", "maxProducts": 1000}'
```

```javascript
const { ApifyClient } = require('apify-client');
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('<ACTOR_ID>').call({ storeUrl: 'https://yourstore.com' });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const feed = items.filter(r => r.recordType === 'product' && r.agentReady);
```

Schedule it weekly with a `monitorId` per store and read only the `diff-summary` rows for change alerts — a complete **price monitoring** setup for Shopify catalogs in one actor.

### Use cases

- **Shopify catalog export** for ChatGPT Shopping feed / agentic commerce readiness before Q4
- **Product feed audit** for agencies: per-client readiness scores and fix-it lists on a schedule
- **OpenAI product feed** preparation: know GTIN/availability coverage before you submit
- **Price monitoring Shopify** competitors: track price/stock drift per store
- Feed QA for `shopify products json` data pipelines and **product feed validator** workflows

### Rolling out

- **ChatGPT Shopping placement check** (`enableShoppingCheck`): will report whether your products actually surface in ChatGPT Shopping results. Not yet active and never charged — enabling it today adds a free status row while the run proceeds normally.

### What this actor does not do

- No guaranteed ChatGPT / Gemini / AI-Mode / ads placement — placement is the platform's decision.
- No credentialed feed submission — it prepares and validates; you submit via your merchant tooling.
- Public catalog data only: no logins, no private APIs, and public data alone cannot prove full UCP checkout compliance.

### FAQ

**Which stores work?** Any public Shopify store, including most headless storefronts (JSON-LD path). Password-protected stores don't.

**How fast is it?** Catalogs served by `/products.json` extract at ~250 products/request — a 1,000-product store takes seconds. Headless stores fall back to per-page parsing and run slower.

**What if my store blocks the scraper?** Switch `proxyConfiguration` to residential in the input. Extraction failures are always free.

**Where is my monitoring history?** In a named key-value store (`chatgpt-shopping-snapshots`) in your own Apify account — it persists indefinitely.

# Actor input Schema

## `storeUrl` (type: `string`):

Public Shopify store, e.g. https://yourstore.com. The catalog is read from public JSON endpoints (/products.json, collection JSON, per-product JSON) — no browser, no credentials.

## `maxProducts` (type: `integer`):

Hard cap on extracted products (and therefore on agent-ready-product charges).

## `monitorId` (type: `string`):

Optional stable key for drift monitoring. Runs sharing a monitorId diff against each other (price/stock/attribute/error changes) — free. Defaults to the store hostname.

## `monitoring` (type: `boolean`):

Free: compare with the previous run under the same monitorId and store a snapshot in a named key-value store in your account.

## `maxCostUsd` (type: `integer`):

The run refuses to start (uncharged beyond the start fee) if the worst-case estimate exceeds this.

## `proxyConfiguration` (type: `object`):

Residential by default — Shopify blocks datacenter ranges (measured). The JSON-endpoint extraction path keeps residential usage tiny (~4MB per 1,000 products).

## `enableShoppingCheck` (type: `boolean`):

Rolling out — not yet active and never charged. When it ships, this will report whether your products appear in ChatGPT Shopping results. Enabling it today adds a free status row and the run proceeds normally.

## `debug` (type: `boolean`):

Verbose logging for troubleshooting.

## Actor input object example

```json
{
  "storeUrl": "https://www.allbirds.com",
  "maxProducts": 1000,
  "monitoring": true,
  "maxCostUsd": 15,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "enableShoppingCheck": false,
  "debug": false
}
```

# Actor output Schema

## `feed` (type: `string`):

One normalized record per product with validation errors and agent-ready flag, plus one free store-summary row, optional free diff rows, and uncharged usage rows. recordType discriminates the row kind.

# 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 = {
    "storeUrl": "https://www.allbirds.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("george.the.developer/shopify-agentic-commerce-product-feed").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 = { "storeUrl": "https://www.allbirds.com" }

# Run the Actor and wait for it to finish
run = client.actor("george.the.developer/shopify-agentic-commerce-product-feed").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 '{
  "storeUrl": "https://www.allbirds.com"
}' |
apify call george.the.developer/shopify-agentic-commerce-product-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,george.the.developer/shopify-agentic-commerce-product-feed"
        }
    }
}

```

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/zi7M97FNhyGzTm7Y3/builds/icF9eim639fkFKMjj/openapi.json