# Product Catalog Quality Auditor (`publeex/product-catalog-quality-auditor`) Actor

Audit product structured data, metadata, canonicals, indexing flags, and images on publicly accessible shop pages.

- **URL**: https://apify.com/publeex/product-catalog-quality-auditor.md
- **Developed by:** [Publeex Automation](https://apify.com/publeex) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 product-audits

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/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

## Product Catalog Quality Auditor — Product SEO & Structured Data Checks

Run a lightweight **product schema checker, product SEO audit, and e-commerce product data validation** on public product pages. Identify missing structured data, price and stock markup, and basic on-page SEO issues in batches of up to 100 URLs. No login or private API keys required.

### Who it is for

- E-commerce owners and product feed managers checking their own public catalog pages.
- SEO specialists validating product metadata after a site update.
- Developers building lightweight catalog QA jobs with Apify API or scheduled runs.

### What it checks

- Product evidence in **Schema.org Product JSON-LD**, product microdata, or product Open Graph markers.
- Declared product **name, brand, price, currency, availability, SKU and GTIN** when provided in static HTML.
- HTML title, meta description, canonical URL, H1 count, Product JSON-LD completeness and alt text on HTML images.
- Signals including `noindex`, missing identifiers and incomplete social preview metadata.
- A **0–100 heuristic quality score** and an actionable issue list (only for recognized product pages).

### Quick start

1. **Try the prefilled example URL** and click Start to see an actual audit result.
2. Replace it with 1–100 publicly accessible **product detail page** URLs that you are authorized to check.
3. Open **Output** and export findings as JSON/CSV, or use the Apify API.

The sample is a test product with publicly available JSON-LD. A successful sample audit does not guarantee compatibility with every live storefront.

Example input:

```json
{
  "urls": ["https://testingurl.dev/scraping/structured-data/product-json-ld"]
}
```

Example successful output (shortened):

```json
{
  "status": "audited",
  "score": 100,
  "productEvidence": "json_ld",
  "productName": "Vertex Air Laptop 107",
  "productPrice": "86.00",
  "currency": "USD",
  "availability": "https://schema.org/InStock",
  "issueCount": 0,
  "issues": []
}
```

### Output statuses and billing

| Status | Meaning | `product-audit` event |
|---|---|---|
| `audited` | Product signal confirmed; audit produced | One event |
| `product_unconfirmed` | HTML fetched but no accepted product signal detected | No event |
| `skipped` | URL rejected, blocked by robots policy, or inaccessible | No event |

**Pricing model:** Pay per event (PPE). The intended primary paid event is **`product-audit`**. Verify the actual price displayed in the Apify Store Pricing tab before running. Developer-suggested initial price: **$0.005 per successfully audited product** ($5 / 1,000). Charges for Actor start and default dataset items should be disabled or zero-priced if billing only for valid audits is desired. Platform usage is intended to be included in the event price, not passed through separately.

### Responsible use and limitations

- Operates on **public HTTP(S) HTML pages only**; no private pages, credentials, protected networks, or access-control bypasses.
- Verifies `robots.txt` before fetching. If rules cannot be verified or access is disallowed, the page is **skipped**. This does not definitively establish that scraping the website is prohibited.
- Does not execute client-side JavaScript or render a browser. JS-injected prices and product markup may be absent from the results.
- HTML and response content are size-limited; request pacing is conservative. Up to 100 input URLs per run.
- Extracted values reflect the HTML returned at the time of the audit. Real-world stock, final checkout price, GTIN ownership, and content consistency are **not independently verified**.
- The score is a **custom heuristic**, not Google's Rich Results Test or a guarantee of indexing, merchant eligibility, search ranking, or sales.
- Some pages can have complete structured data but still perform poorly in search or sales; a score of 100 means only that this limited checklist found no issues.
- Respect applicable website terms, privacy law, and rights when selecting sites to audit.

### Troubleshooting

- **`skipped`:** Check `reasonCode`/`reason`. Common causes: `robots_http_error`, `robots_timeout`, `robots_disallow`, `page_http_error`, `page_timeout`.
- **`product_unconfirmed`:** The page might not contain server-rendered Product metadata. A browser-based tool or official product feed may be needed for that store.
- **Missing price or brand:** The website may publish this data only through JavaScript, or use a structure outside this lightweight parser's current scope.

### Integrations

Run on schedules or from the Apify API and use the resulting dataset in custom workflows, dashboards and product catalog QA pipelines. No external API keys are needed.

### Version and support

This is an early-stage release. Feedback, reproducible issue reports and suggestions for supported product structures are welcome through the Actor's Issues tab.

### Apify Store output schema

The Actor output is declared in `.actor/output_schema.json` and linked from `.actor/actor.json`. The `results` output links to the default dataset, which contains one record per URL including completed audits and free diagnostics. The structured dataset fields/views are defined in `.actor/dataset_schema.json`.

# Actor input Schema

## `urls` (type: `array`):

Enter 1–100 public product detail URLs (https://). The prefilled URL is a safe example for your first run. Sites with inaccessible robots.txt are skipped.

## Actor input object example

```json
{
  "urls": [
    "https://testingurl.dev/scraping/structured-data/product-json-ld"
  ]
}
```

# Actor output Schema

## `results` (type: `string`):

JSON dataset with product audit findings, quality scores and diagnostics for pages not audited.

# 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 = {
    "urls": [
        "https://testingurl.dev/scraping/structured-data/product-json-ld"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("publeex/product-catalog-quality-auditor").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 = { "urls": ["https://testingurl.dev/scraping/structured-data/product-json-ld"] }

# Run the Actor and wait for it to finish
run = client.actor("publeex/product-catalog-quality-auditor").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 '{
  "urls": [
    "https://testingurl.dev/scraping/structured-data/product-json-ld"
  ]
}' |
apify call publeex/product-catalog-quality-auditor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,publeex/product-catalog-quality-auditor"
        }
    }
}
```

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/OwzMx6KVDDfzdxJIB/builds/jYckBDTW5NUnDboLw/openapi.json