# Google Merchant Feed Audit API (`webdata_labs/feedfix-api`) Actor

\[💵 $3-5 / 1K] AI-powered Google Merchant feed audits with normalized attributes, missing-field detection, evidence, and structured product titles.

- **URL**: https://apify.com/webdata\_labs/feedfix-api.md
- **Developed by:** [WebData Labs](https://apify.com/webdata_labs) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 product feed audits

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

**Turn messy product catalog rows into explainable Google Merchant feed audits - without inventing missing attributes.**

FeedFix API accepts public product titles, descriptions, and existing attributes, then returns a stable JSON audit with taxonomy, normalized fields, missing data, violations, evidence, confidence, and a compliant AI-generated structured title. It is an enrichment API, not a product scraper and not a guarantee of Google Merchant approval.

### ✅ What you get / ❌ What this isn't

✅ One structured audit row per successfully processed product  
✅ Evidence spans for extracted attributes  
✅ Missing fields reported instead of hallucinated values  
✅ Google Merchant `structured_title` source marker  
✅ JSON, CSV, Excel, API, scheduling, webhooks, and Apify integrations

❌ No website scraping or image analysis  
❌ No invented GTINs, brands, materials, or specifications  
❌ No automatic upload to Merchant Center  
❌ No guarantee that Google will approve a listing

### 🔎 Why use this product feed audit API

- Preflight a supplier feed before importing it into your store or ad workflow.
- Normalize inconsistent catalog attributes across multiple suppliers.
- Identify missing identifiers and product details at batch scale.
- Generate factual structured titles with the required AI source marker.
- Route low-confidence rows to human review using `confidence` and `status`.

### 📊 What data you get

| Field                      | Type   | Description                               |
| -------------------------- | ------ | ----------------------------------------- |
| `status`                   | string | `valid`, `needs_changes`, or `rejected`   |
| `qualityScore`             | number | Feed quality score from 0 to 100          |
| `category`                 | object | Best-supported Google taxonomy category   |
| `normalizedAttributes`     | object | Evidence-backed normalized values         |
| `missingAttributes`        | array  | Important fields absent from the input    |
| `violations`               | array  | Machine-readable issues and explanations  |
| `suggestedStructuredTitle` | object | Suggested title plus the AI source marker |
| `confidence`               | number | Overall confidence from 0 to 1            |
| `evidence`                 | array  | Input spans supporting extracted values   |

### 👥 Who it is for

- Shopify and WooCommerce agencies
- PPC and Google Shopping specialists
- Marketplace operators
- Catalog and PIM teams
- Feed management SaaS products
- Developers building product ingestion pipelines

### ⚙️ How to audit a Google Merchant product feed

1. Open the Actor input.
2. Paste one or more product objects into `products`.
3. Run the Actor.
4. Review the dataset and route low-confidence or rejected rows to a person.
5. Download JSON, CSV, Excel, or call the Actor through the Apify API.

### 📥 Input

```json
{
    "products": [
        {
            "id": "sample-sku-42",
            "title": "Example Air Runner black men's shoes size 42",
            "description": "Lightweight black running shoes for men with a mesh upper.",
            "brand": "Example",
            "attributes": { "size": "42", "color": "black" }
        }
    ],
    "concurrency": 5
}
````

Each run accepts up to 1,000 products. A product must contain a title or description. Only send public, non-sensitive catalog data. Do not submit credentials, private customer information, confidential supplier terms, or proprietary documents.

### 📤 Output

```json
{
    "inputId": "sample-sku-42",
    "status": "needs_changes",
    "qualityScore": 82,
    "category": { "id": "187", "name": "Apparel & Accessories > Shoes" },
    "normalizedAttributes": { "brand": "Example", "color": "Black", "size": "42" },
    "missingAttributes": ["gtin", "material"],
    "violations": [],
    "suggestedStructuredTitle": {
        "content": "Example Men's Black Running Shoes, Size 42",
        "digitalSourceType": "trained_algorithmic_media"
    },
    "confidence": 0.93,
    "evidence": [{ "field": "color", "value": "Black", "sourceText": "black running shoes" }]
}
```

You can download the dataset in JSON, HTML, CSV, or Excel format. Programmatic callers can use the API tab and dataset endpoint.

### 💵 How much does a product feed audit cost?

The planned Store pricing charges for each successfully audited product:

| Event                             | Free | Bronze | Silver | Gold |
| --------------------------------- | ---: | -----: | -----: | ---: |
| Product audit, per 1,000 products |   $5 |     $4 |  $3.50 |   $3 |

For example, a 100-product test costs $0.50 on the Free tier. Failed validation and internal API failures do not produce a paid dataset result. Final live pricing is always shown in the Actor's Pricing tab.

### 🔁 Run it on the Apify platform

Use Apify schedules for recurring catalog QA, webhooks for downstream imports, and integrations with Make, Zapier, Google Sheets, or your own application. Set a maximum run charge when calling a pay-per-event Actor to cap spend.

### ⚠️ Limits and data handling

- Model output can be wrong. Review material commercial or compliance decisions.
- Taxonomy IDs depend on the model's available knowledge and should be verified before bulk import.
- This Actor is designed for public, non-sensitive product content because its underlying API project may share inputs and outputs with OpenAI.
- Product text is treated as untrusted data and cannot override the audit instructions.
- Only successful product audit rows are written to the default dataset.

### ❓ FAQ

#### Is this a Google Merchant API?

It prepares and audits product data for Google Merchant workflows, but it does not call Merchant Center or upload feeds.

#### Does it scrape product pages?

No. You provide the product text and attributes. This keeps runs fast, predictable, and suitable for existing feed pipelines.

#### Will it invent missing attributes?

It is explicitly instructed to report missing values instead of guessing, and it supplies evidence for extracted fields. Model mistakes remain possible, so use confidence thresholds and human review.

### 🛠️ Support

For a problem, open the Actor's Issues tab and include the run URL, a sanitized example input, and the expected behavior. Never post API keys or confidential catalog data in an issue.

# Actor input Schema

## `products` (type: `array`):

Public, non-sensitive product catalog rows to audit. Maximum 1,000 per run.

## `target` (type: `string`):

Marketplace feed specification used for the audit.

## `concurrency` (type: `integer`):

Number of product audits processed in parallel.

## Actor input object example

```json
{
  "products": [
    {
      "id": "sample-sku-42",
      "title": "Example Air Runner black men's shoes size 42",
      "description": "Lightweight black running shoes for men with a mesh upper.",
      "brand": "Example",
      "language": "en",
      "attributes": {
        "size": "42",
        "color": "black"
      }
    }
  ],
  "target": "google_merchant",
  "concurrency": 5
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing one structured audit result per 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 = {
    "products": [
        {
            "id": "sample-sku-42",
            "title": "Example Air Runner black men's shoes size 42",
            "description": "Lightweight black running shoes for men with a mesh upper.",
            "brand": "Example",
            "language": "en",
            "attributes": {
                "size": "42",
                "color": "black"
            }
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdata_labs/feedfix-api").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 = { "products": [{
            "id": "sample-sku-42",
            "title": "Example Air Runner black men's shoes size 42",
            "description": "Lightweight black running shoes for men with a mesh upper.",
            "brand": "Example",
            "language": "en",
            "attributes": {
                "size": "42",
                "color": "black",
            },
        }] }

# Run the Actor and wait for it to finish
run = client.actor("webdata_labs/feedfix-api").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "products": [
    {
      "id": "sample-sku-42",
      "title": "Example Air Runner black men'\''s shoes size 42",
      "description": "Lightweight black running shoes for men with a mesh upper.",
      "brand": "Example",
      "language": "en",
      "attributes": {
        "size": "42",
        "color": "black"
      }
    }
  ]
}' |
apify call webdata_labs/feedfix-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=webdata_labs/feedfix-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Merchant Feed Audit API",
        "description": "[💵 $3-5 / 1K] AI-powered Google Merchant feed audits with normalized attributes, missing-field detection, evidence, and structured product titles.",
        "version": "0.1",
        "x-build-id": "JWBs0Kag90uIVe8tv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/webdata_labs~feedfix-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-webdata_labs-feedfix-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/webdata_labs~feedfix-api/runs": {
            "post": {
                "operationId": "runs-sync-webdata_labs-feedfix-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/webdata_labs~feedfix-api/run-sync": {
            "post": {
                "operationId": "run-sync-webdata_labs-feedfix-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "products"
                ],
                "properties": {
                    "products": {
                        "title": "Products",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Public, non-sensitive product catalog rows to audit. Maximum 1,000 per run.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "id": {
                                    "type": "string",
                                    "title": "Product ID",
                                    "description": "Your stable SKU or catalog identifier."
                                },
                                "title": {
                                    "type": "string",
                                    "title": "Title",
                                    "description": "Current product title."
                                },
                                "description": {
                                    "type": "string",
                                    "title": "Description",
                                    "description": "Current public product description."
                                },
                                "brand": {
                                    "type": "string",
                                    "title": "Brand",
                                    "description": "Current product brand when known."
                                },
                                "category": {
                                    "type": "string",
                                    "title": "Existing category",
                                    "description": "Current supplier or store category."
                                },
                                "language": {
                                    "type": "string",
                                    "title": "Language",
                                    "description": "BCP 47 language code such as en, de, or uk."
                                },
                                "attributes": {
                                    "type": "object",
                                    "title": "Existing attributes",
                                    "description": "Existing product attribute key-value pairs.",
                                    "editor": "json"
                                }
                            }
                        }
                    },
                    "target": {
                        "title": "Target feed",
                        "enum": [
                            "google_merchant"
                        ],
                        "type": "string",
                        "description": "Marketplace feed specification used for the audit.",
                        "default": "google_merchant"
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of product audits processed in parallel.",
                        "default": 5
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
