Product Feed Validator

Understanding Product Feed Validation

Product feed validation is a critical process for e-commerce merchants who want to advertise their products across Google Shopping, Amazon Marketplace, Meta Commerce (Facebook and Instagram Shops), Microsoft Advertising, and other digital marketplaces. A properly validated feed ensures your products appear correctly in search results, shopping ads, and marketplace listings, maximizing visibility and conversions.

When you submit a product feed to platforms like Google Merchant Center, the platform parses your data and checks it against a comprehensive set of requirements. These requirements cover everything from basic field presence (such as ensuring every product has a title, description, and price) to complex validation rules (like verifying GTIN checksums, checking image accessibility, and validating category mappings). Feeds that fail validation may result in product disapprovals, limited reach, or complete feed rejection.

Our Feed Validator performs the same comprehensive checks that major marketplaces use, but before you submit your feed. This proactive approach allows you to identify and fix issues early, reducing the time between feed submission and product approval. The validator supports multiple feed formats including XML (Google Product Data Specification), CSV/TSV files, and JSON feeds, making it compatible with virtually any e-commerce platform or feed management system.

Why Feed Validation Matters for E-commerce Success

The quality of your product feed directly impacts your advertising performance and marketplace visibility. Products with incomplete or incorrectly formatted data may not appear in relevant searches, leading to missed sales opportunities. Even worse, systematic feed errors can result in account suspensions or policy violations that take significant time and effort to resolve.

Consider the complexity of modern product data requirements: Google Merchant Center alone has dozens of required and recommended attributes, each with specific formatting rules. A single product listing might need a title under 150 characters, a description between 500-5000 characters, a price in the correct currency format, valid GTIN or MPN identifiers, accessible image URLs meeting size and format requirements, accurate availability status, proper category mapping to the Google Product Taxonomy, and compliant shipping and tax information. Multiply this by thousands of products in a typical catalog, and the potential for errors becomes substantial.

Deep Structural Analysis

Our validator examines your feed structure at multiple levels, checking XML schema compliance, CSV column mappings, and JSON structure validity. We verify that all required parent-child relationships are maintained and that nested elements follow platform specifications.

GTIN/UPC/EAN Validation

Product identifiers like GTINs must pass checksum validation to be accepted. We verify the mathematical validity of 8, 12, 13, and 14-digit GTINs, UPCs, EANs, and ISBNs using industry-standard check digit algorithms.

Image URL Verification

Broken or incorrectly formatted image URLs are a leading cause of product disapprovals. We check that image URLs are accessible, return valid image responses, and meet minimum resolution requirements for each platform.

Category Mapping Checks

Proper category assignment improves product discoverability. We validate that your category values match the target platform's taxonomy and flag deprecated or invalid category IDs that could cause listing issues.

Price and Currency Validation

Price formatting errors can lead to incorrect listings or policy violations. We verify currency codes, decimal formatting, sale price relationships, and price consistency across product variants.

Content Length Compliance

Each platform has specific character limits for titles, descriptions, and other text fields. We check against these limits and provide recommendations for optimal content length to maximize visibility.

Google Merchant Center Requirements

Google Merchant Center has specific requirements for product data that must be met for your products to appear in Shopping ads, free product listings, and other Google surfaces. Understanding these requirements is essential for feed optimization and avoiding disapprovals.

Required Attributes for All Products

Attribute	Description	Status
id	Unique identifier for each product (max 50 characters)	Required
title	Product name (max 150 characters, 70 recommended)	Required
description	Product description (max 5000 characters)	Required
link	URL of the product landing page	Required
image_link	URL of the main product image (min 100x100 pixels)	Required
price	Product price with currency (e.g., "19.99 USD")	Required
availability	in_stock, out_of_stock, preorder, or backorder	Required
brand	Product brand name	Recommended
gtin	Global Trade Item Number (UPC, EAN, ISBN)	Recommended
google_product_category	Google's product taxonomy category ID or path	Recommended

Common Validation Errors and Solutions

Understanding the most frequent feed errors helps you proactively address issues before submission. Here are the validation problems our tool most commonly identifies:

Missing Required Fields

Products lacking essential attributes like title, price, or availability cannot be processed. Ensure every product includes all required fields with valid, non-empty values.

Broken Image URLs

Image links returning 404 errors or redirecting to error pages cause disapprovals. Verify all image URLs are accessible and return valid image content.

Invalid GTIN Checksums

GTINs must pass mathematical checksum validation. Incorrect digits or transposition errors will cause the entire identifier to be rejected.

Feed Validation API Examples

Integrate feed validation directly into your workflow using our REST API. Below are code examples showing how to validate feeds programmatically in various languages.

# Validate a feed file using cURL
curl -X POST https://api.productcategorization.com/v1/feed/validate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: multipart/form-data" \
  -F "feed_file=@/path/to/your/products.xml" \
  -F "format=google" \
  -F "validations=required_fields,gtin_check,image_urls"

# Validate a feed from URL
curl -X POST https://api.productcategorization.com/v1/feed/validate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "feed_url": "https://example.com/products.xml",
    "format": "google",
    "validations": ["required_fields", "gtin_check", "image_urls"]
  }'

import requests

# Initialize API client
api_key = "YOUR_API_KEY"
base_url = "https://api.productcategorization.com/v1"

def validate_feed_file(file_path, format_type="google"):
    """Validate a local feed file"""
    headers = {"Authorization": f"Bearer {api_key}"}

    with open(file_path, "rb") as f:
        files = {"feed_file": f}
        data = {
            "format": format_type,
            "validations": "required_fields,gtin_check,image_urls,price_format"
        }

        response = requests.post(
            f"{base_url}/feed/validate",
            headers=headers,
            files=files,
            data=data
        )

    return response.json()

def validate_feed_url(feed_url, format_type="google"):
    """Validate a feed from URL"""
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }

    payload = {
        "feed_url": feed_url,
        "format": format_type,
        "validations": ["required_fields", "gtin_check", "image_urls"]
    }

    response = requests.post(
        f"{base_url}/feed/validate",
        headers=headers,
        json=payload
    )

    return response.json()

# Example usage
result = validate_feed_file("products.xml")
print(f"Feed Score: {result['score']}")
print(f"Errors: {result['error_count']}")
print(f"Warnings: {result['warning_count']}")

// Feed Validation API Client for JavaScript/Node.js
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://api.productcategorization.com/v1';

// Validate feed from file
async function validateFeedFile(filePath, format = 'google') {
    const form = new FormData();
    form.append('feed_file', fs.createReadStream(filePath));
    form.append('format', format);
    form.append('validations', 'required_fields,gtin_check,image_urls');

    const response = await axios.post(
        `${BASE_URL}/feed/validate`,
        form,
        {
            headers: {
                ...form.getHeaders(),
                'Authorization': `Bearer ${API_KEY}`
            }
        }
    );

    return response.data;
}

// Validate feed from URL
async function validateFeedUrl(feedUrl, format = 'google') {
    const response = await axios.post(
        `${BASE_URL}/feed/validate`,
        {
            feed_url: feedUrl,
            format: format,
            validations: ['required_fields', 'gtin_check', 'image_urls']
        },
        {
            headers: {
                'Authorization': `Bearer ${API_KEY}`,
                'Content-Type': 'application/json'
            }
        }
    );

    return response.data;
}

// Example usage
(async () => {
    const result = await validateFeedUrl('https://example.com/feed.xml');
    console.log('Feed Score:', result.score);
    console.log('Issues:', result.issues);
})();

<?php
// Feed Validation API Client for PHP

class FeedValidator {
    private $apiKey;
    private $baseUrl = 'https://api.productcategorization.com/v1';

    public function __construct($apiKey) {
        $this->apiKey = $apiKey;
    }

    // Validate feed from file upload
    public function validateFile($filePath, $format = 'google') {
        $curl = curl_init();

        $postFields = [
            'feed_file' => new CURLFile($filePath),
            'format' => $format,
            'validations' => 'required_fields,gtin_check,image_urls,price_format'
        ];

        curl_setopt_array($curl, [
            CURLOPT_URL => $this->baseUrl . '/feed/validate',
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_POST => true,
            CURLOPT_POSTFIELDS => $postFields,
            CURLOPT_HTTPHEADER => [
                'Authorization: Bearer ' . $this->apiKey
            ]
        ]);

        $response = curl_exec($curl);
        curl_close($curl);

        return json_decode($response, true);
    }

    // Validate feed from URL
    public function validateUrl($feedUrl, $format = 'google') {
        $curl = curl_init();

        $payload = json_encode([
            'feed_url' => $feedUrl,
            'format' => $format,
            'validations' => ['required_fields', 'gtin_check', 'image_urls']
        ]);

        curl_setopt_array($curl, [
            CURLOPT_URL => $this->baseUrl . '/feed/validate',
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_POST => true,
            CURLOPT_POSTFIELDS => $payload,
            CURLOPT_HTTPHEADER => [
                'Authorization: Bearer ' . $this->apiKey,
                'Content-Type: application/json'
            ]
        ]);

        $response = curl_exec($curl);
        curl_close($curl);

        return json_decode($response, true);
    }
}

// Example usage
$validator = new FeedValidator('YOUR_API_KEY');
$result = $validator->validateUrl('https://example.com/feed.xml');

echo "Score: " . $result['score'] . "\n";
echo "Errors: " . $result['error_count'] . "\n";
?>

Feed Quality Visualization

Visual representations help you quickly understand your feed's health and identify patterns in validation issues.

Issue Distribution

Validation Progress

Multi-Platform Feed Requirements Comparison

Different marketplaces have varying requirements for product data. Understanding these differences is crucial when managing feeds across multiple platforms. Our validator checks against all major marketplace specifications to ensure cross-platform compatibility.

Google Merchant Center

Supports both XML and text/TSV formats. Requires title, description, link, image_link, price, and availability. Strong emphasis on GTIN for branded products and proper category mapping to Google's taxonomy of over 6,000 categories.

Amazon Marketplace

Uses inventory file templates specific to each product category. Requires ASIN or UPC for existing products. Has strict requirements for product identifiers, condition, and category-specific attributes like size and color for apparel.

Meta Commerce

Supports XML and CSV formats for Facebook and Instagram Shops. Requires id, title, description, availability, condition, price, link, and image_link. Supports rich product variants and collection groupings.

Microsoft Advertising

Similar to Google's format with some variations. Supports Bing Shopping campaigns with product listings. Requires standard attributes plus Microsoft-specific fields like seller_name for marketplace listings.

GTIN Validation Deep Dive

Global Trade Item Numbers (GTINs) are crucial for product identification across marketplaces. Our validator performs comprehensive GTIN checks including format validation, checksum verification, and prefix analysis. Here is what we check for each GTIN type:

GTIN-8 (EAN-8): 8-digit codes typically used for small products. We verify the check digit using the standard alternating weight algorithm.
GTIN-12 (UPC-A): 12-digit codes standard in North America. Common issues include leading zero omission and transcription errors.
GTIN-13 (EAN-13): 13-digit international codes. We validate the GS1 company prefix structure and check digit.
GTIN-14: 14-digit codes for case/carton identification. Includes packaging indicator digit validation.
ISBN-10/13: Book identifiers with their own checksum algorithms. ISBN-10 uses modulo 11, ISBN-13 uses standard GTIN-13 validation.

Feed Optimization Best Practices

Beyond basic validation, optimizing your product feed can significantly improve your advertising performance and organic visibility. Here are expert recommendations for maximizing feed effectiveness:

Title Optimization Strategies

Your product title is the most important attribute for both visibility and click-through rates. While Google allows up to 150 characters, the optimal length varies by product category and device. Follow these guidelines for maximum impact:

Include brand name at the beginning for branded products
Add key product attributes like size, color, and material
Use natural language rather than keyword stuffing
Keep the most important information in the first 70 characters (mobile display limit)
Avoid promotional text like "Free Shipping" or "Best Price"

Image Quality Requirements

High-quality product images dramatically impact click-through and conversion rates. Each platform has specific image requirements:

Minimum resolution of 100x100 pixels (500x500 recommended for zoom functionality)
Use white or transparent backgrounds for apparel and non-apparel products respectively
Product should fill 75-90% of the image frame
No watermarks, promotional overlays, or borders
Include multiple angles using additional_image_link attribute

Feed Update Frequency

Regular feed updates ensure your product data remains accurate and competitive. We recommend:

Daily updates for price and availability changes
Immediate updates when products go out of stock
Weekly reviews for attribute optimization opportunities
Monthly audits for category mapping accuracy

Ready to Optimize Your Product Feeds?

Get access to advanced validation features, bulk processing, and automated feed monitoring.

View Pricing Plans

Frequently Asked Questions

What feed formats does the validator support?

Our validator supports all major feed formats including XML (RSS 2.0, Atom, Google Product Data Specification), CSV/TSV text files, and JSON feeds. We automatically detect the format based on file content and structure, or you can specify the format manually for more accurate validation against specific marketplace requirements.

How does GTIN checksum validation work?

GTIN validation uses the modulo 10 check digit algorithm standardized by GS1. We multiply each digit by alternating weights of 1 and 3, sum the products, and verify the check digit makes the total divisible by 10. For ISBN-10, we use a different algorithm with weights 10 through 2 and modulo 11. Invalid checksums typically indicate data entry errors or counterfeit identifiers.

Why are my image URLs failing validation?

Image URL failures can occur for several reasons: the server returns a non-200 HTTP status, the URL redirects more than the allowed number of times, the content type is not a valid image format, the image dimensions are below minimum requirements, or the URL contains special characters that need encoding. Our detailed error messages identify the specific issue for each failed image.

How often should I validate my product feeds?

We recommend validating your feed before every submission to a marketplace, and setting up automated validation whenever your product data changes. For large catalogs with frequent updates, daily validation helps catch issues before they impact your listings. Our API makes it easy to integrate validation into your existing feed management workflow.

What is the difference between errors and warnings?

Errors are issues that will cause product disapprovals or feed rejection - these must be fixed before submission. Warnings indicate potential problems or optimization opportunities that won't necessarily cause disapprovals but may impact performance. For example, a missing required field is an error, while a title exceeding the recommended length is a warning.

Can I validate feeds for multiple marketplaces at once?

Yes, our validator can check your feed against multiple marketplace specifications in a single validation run. This is particularly useful for merchants selling across Google Shopping, Amazon, and Meta Commerce, as you can identify platform-specific issues and optimize your feed for cross-platform compatibility.

Validating Your Feed