Why is google merchant center video processing stuck and how to fix your woocommerce feed

#Why is Google Merchant Center video processing stuck and how to fix your WooCommerce feed

Product demonstration videos have emerged as one of the most effective conversion drivers in contemporary e-commerce. Google Shopping and free product listings across Google search surfaces actively showcase products with dynamic short-form videos, unboxing clips, and interactive demonstrations. Google states the purpose of the new attribute plainly: product videos show items in use or from various angles, and Google uses them to enhance how products are displayed across its surfaces (Merchant Center product data specification update 2026).

Despite these clear advantages, merchants operating WooCommerce stores frequently encounter a disruptive technical road block. After adding video URLs to their product catalog feeds, Google Merchant Center reports a persistent video processing status for days on end. Eventually, the video disappears from the product view or gets dropped without a helpful diagnostic explanation. For stores managing thousands of product variants, the videos simply never appear, and the status offers no hint about the cause.

This in-depth architectural guide details why Google’s media ingestion pipeline stalls, breaks down MP4 container mechanics, outlines practical fixes for Cloudflare WAF and CDN bottlenecks, and delivers production-grade PHP code for WooCommerce schema injection and dynamic XML feeds.

#Why video processing is stuck in Google Merchant Center

When an e-commerce platform passes a video URL inside an XML feed or through the Merchant API, Merchant Center does not directly embed your external media file in search results. Instead, it initiates an automated media ingestion and validation workflow. The first step is a fetch: the attribute’s help page requires that Googlebot can reach the video, and Google’s crawler list names Googlebot-Video as the agent for video-dependent products. If that fetch fails or times out, the video never reaches review.

This ingestion pipeline typically gets stuck in an unresolved processing loop due to four distinct engineering factors:

First and foremost is suboptimal atom placement within the MP4 container structure. Video rendering software packages, such as Adobe Premiere, Final Cut Pro, or standard camera pipelines, commonly append the moov atom (which houses index tables, timing markers, and frame references) at the very end of the file, following the bulk mdat audiovisual payload. For desktop players loading files locally, this layout is harmless. However, Google’s media ingestion crawler relies on inspecting the initial few kilobytes of a file to extract resolution, aspect ratio, frame rate, and codec profile. When the moov index is trapped at the end of an 80-megabyte file, the crawler must stream the entire file before beginning decoding. If your origin server throttles bandwidth or suffers latency spikes, Google’s worker reaches its timeout limit and abandons the job, leaving the entry indefinitely queued.

The second culprit is missing support for HTTP Range Requests on your origin web server or CDN. Google’s media ingest bot sends request headers specifying byte ranges, such as Range: bytes=0-1048575. A compliant web server must respond with HTTP status 206 Partial Content along with a corresponding Content-Range header, transferring only the requested byte chunk. If your WordPress hosting stack, a caching plugin, or a custom PHP download handler bypasses range parsing and returns an unconditional 200 OK with the complete payload, the crawler has to pull the whole file to read it, which runs into the same timeout as a moov atom at the end.

The third challenge stems from overzealous edge firewalls and Web Application Firewall rules. Cloudflare, AWS CloudFront, and Sucuri frequently employ automated bot detection systems, including Cloudflare Bot Fight Mode or Managed Challenges. Because Googlebot-Video crawlers use different IP subnets and transport fingerprints than standard Googlebot HTML crawlers, bot mitigation modules often intercept video requests with JavaScript challenges or 403 Forbidden responses. Google Merchant Center never receives the raw media stream; instead, it receives an HTML firewall page, triggering an opaque processing error.

The fourth issue is the file itself. Google’s specification lists accepted containers and hard limits (covered in the next section), not codec profiles, so variable frame rates, YUV 4:4:4 or 10-bit color are not documented reasons for rejection. Normalizing to H.264 with yuv420p and a constant frame rate, as the ffmpeg recipe below does, removes them as a variable while you debug.

#Google Merchant Center video requirements for video_link

Before you debug servers, check the file against the published limits. The help page for the attribute (Video link [video_link]) lists them:

Three rules on the same page explain many “processing” cases that have nothing to do with the server. A URL outside YouTube must point directly to the raw video file, not to a page that contains a player, so a link to the product page does not qualify. The video must be publicly accessible: Googlebot has to fetch it without a login or token, and robots.txt must not block it. The link must also be static, which means it should not expire and should not be reused later for a different video. Signed CDN URLs with a short lifetime break that rule.

Google adds that the merchant must hold the marketing rights to the video, that videos must not be blurry or out of focus, and that sound is optional. In feeds with several videos per product, separate the URLs with commas in a text feed, or repeat the element in XML.

#How to optimize MP4 files with faststart for Google Shopping

Resolving the ingestion bottleneck at the source requires ensuring that every MP4 container exposes its index table at the very beginning of the byte stream. In modern video engineering, this container restructuring is called faststart.

Applying the faststart flag relocates the moov atom ahead of the raw mdat audio and video tracks. As a result, any client, including Googlebot-Video, immediately reads aspect ratios, duration metadata, and audio sample rates upon receiving the initial 32 kilobytes of the stream.

Here is the essential FFmpeg command to rearrange an existing MP4 file without running a time-consuming video re-encoding pass:

ffmpeg -i product-original.mp4 -c copy -movflags +faststart product-faststart.mp4

When raw product footage comes straight from smartphones or studio cameras with irregular frame rates or high bitrates, running a complete normalization pass ensures guaranteed acceptance by Google Shopping:

ffmpeg -i product-raw.mov \
  -c:v libx264 \
  -preset slow \
  -crf 21 \
  -profile:v high \
  -level:v 4.1 \
  -pix_fmt yuv420p \
  -r 30 \
  -g 60 \
  -c:a aac \
  -b:a 160k \
  -ar 48000 \
  -movflags +faststart \
  -max_muxing_queue_size 1024 \
  product-shop-optimized.mp4

In this command, -g 60 mandates an instantaneous decoder refresh (IDR) keyframe exactly every two seconds at 30 frames per second. This frequency allows Google’s crawler to construct scrubbing preview cards instantaneously without requiring deep frame-by-frame decoding across the stream.

For e-commerce operations managing hundreds of product listings, automated directory processing saves countless engineering hours. You can deploy this modular Bash script on your ingestion staging server:

#!/usr/bin/env bash
set -euo pipefail

INPUT_DIR="./raw-videos"
OUTPUT_DIR="./feed-ready-videos"

mkdir -p "$OUTPUT_DIR"

for video in "$INPUT_DIR"/*.{mp4,mov,m4v}; do
  [[ -f "$video" ]] || continue
  filename=$(basename -- "$video")
  name="${filename%.*}"
  output="${OUTPUT_DIR}/${name}.mp4"
  
  echo "Processing: $filename -> $output"
  
  ffmpeg -y -i "$video" \
    -c:v libx264 -preset medium -crf 22 \
    -profile:v high -level:v 4.1 -pix_fmt yuv420p \
    -r 30 -g 60 \
    -c:a aac -b:a 128k -ar 44100 \
    -movflags +faststart \
    "$output"
done

echo "Batch processing finished: All media files prepared with faststart."

#How to configure VideoObject schema in WooCommerce for Google Shopping

Structured data on the product page is a separate channel from the feed: Merchant Center reads video_link, while Google Search reads VideoObject markup on the page. Google’s video structured data guide (Video structured data) requires name, thumbnailUrl and uploadDate, defines contentUrl as the URL of the actual video bytes and embedUrl as the URL of the player itself, and says the markup must sit on a page where users can watch the video. Output the snippet below only on product templates that actually show the video.

To reinforce entity trust, your WooCommerce product pages should publish a comprehensive VideoObject nested within the core Product schema markup. Schema.org provides the subjectOf and video properties specifically to link multimedia demonstrations with commercial products.

The following production PHP snippet attaches directly to the woocommerce_structured_data_product filter, populating the product schema with valid video metadata:

<?php
/**
 * Injects Schema.org VideoObject into WooCommerce Product JSON-LD markup.
 */
declare(strict_types=1);

if (!defined('ABSPATH')) {
    exit;
}

add_filter('woocommerce_structured_data_product', 'wpp_inject_product_video_schema_en', 20, 2);

function wpp_inject_product_video_schema_en(array $markup, WC_Product $product): array
{
    $product_id = $product->get_id();
    
    // Retrieve custom video metadata stored on the product
    $video_url = get_post_meta($product_id, '_wpp_product_video_url', true);
    if (empty($video_url) || !filter_var($video_url, FILTER_VALIDATE_URL)) {
        return $markup;
    }

    $video_title = get_post_meta($product_id, '_wpp_product_video_title', true);
    if (empty($video_title)) {
        $video_title = sprintf('Demonstration and overview of %s', $product->get_name());
    }

    $video_description = get_post_meta($product_id, '_wpp_product_video_desc', true);
    if (empty($video_description)) {
        $video_description = wp_strip_all_tags($product->get_short_description());
        if (empty($video_description)) {
            $video_description = sprintf('Official product demonstration highlighting specifications of %s.', $product->get_name());
        }
    }

    $thumbnail_id = $product->get_image_id();
    $thumbnail_url = $thumbnail_id ? wp_get_attachment_image_url($thumbnail_id, 'full') : '';
    if (empty($thumbnail_url)) {
        $thumbnail_url = wc_placeholder_img_src('full');
    }

    $upload_date = get_the_date('c', $product_id);
    
    $video_object = [
        '@type' => 'VideoObject',
        'name' => esc_html($video_title),
        'description' => esc_html($video_description),
        'thumbnailUrl' => [esc_url($thumbnail_url)],
        'uploadDate' => $upload_date,
        'contentUrl' => esc_url($video_url),
        'inLanguage' => get_bloginfo('language'),
    ];

    // If the video is hosted on YouTube, supply the embedUrl field
    if (preg_match('~(?:youtube\.com/watch\?v=|youtu\.be/)([\w-]{11})~', $video_url, $yt)) {
        unset($video_object['contentUrl']);
        $video_object['embedUrl'] = 'https://www.youtube.com/embed/' . $yt[1];
    }

    // Assign to both subjectOf and video for thorough backward compatibility
    $markup['subjectOf'] = $video_object;
    $markup['video'] = $video_object;

    return $markup;
}

Deploying this snippet ensures that search crawlers encounter complete structural alignment between the catalog feed and the customer-facing storefront.

#How to generate an XML product feed with video_link in WooCommerce

In the Google Merchant Center product specifications, the dedicated attribute for submitting product media is [video_link] (represented as <g:video_link> within XML documents). Google accepts:

1. Direct, fully qualified URLs pointing to public MP4 files hosted on high-throughput storage systems supporting byte-range delivery.
2. Direct URLs pointing to YouTube videos, including standard watch links (https://www.youtube.com/watch?v=ID) or shortened links (https://youtu.be/ID).

Using YouTube links is frequently practical because Google bypasses third-party media ingestion entirely. Transcoding, storage, and safety scans take place within Google’s own network. If your company prefers hosting its own media on Cloudflare Stream or an S3-compatible bucket, ensure the endpoint responds directly without HTTP 301 redirects and serves standard video/mp4 MIME types.

Below is an optimized PHP implementation utilizing XMLWriter to stream a clean Google Merchant Center XML feed from WooCommerce:

<?php
/**
 * High-performance Google Merchant Center XML feed generator with video support.
 */
declare(strict_types=1);

if (!defined('ABSPATH')) {
    exit;
}

add_action('init', 'wpp_register_en_merchant_feed');

function wpp_register_en_merchant_feed(): void
{
    add_feed('google-merchant-video-en', 'wpp_render_en_merchant_feed');
}

function wpp_render_en_merchant_feed(): void
{
    header('Content-Type: application/xml; charset=UTF-8');
    
    $writer = new XMLWriter();
    $writer->openURI('php://output');
    $writer->startDocument('1.0', 'UTF-8');
    $writer->setIndent(true);
    
    $writer->startElement('rss');
    $writer->writeAttribute('version', '2.0');
    $writer->writeAttribute('xmlns:g', 'http://base.google.com/ns/1.0');
    
    $writer->startElement('channel');
    $writer->writeElement('title', get_bloginfo('name') . ' - Video Product Catalog');
    $writer->writeElement('link', home_url('/'));
    $writer->writeElement('description', 'WooCommerce product feed featuring Google Shopping video attributes.');

    $query = new WC_Product_Query([
        'status' => 'publish',
        'limit' => 250,
        'orderby' => 'date',
        'order' => 'DESC',
    ]);
    
    $products = $query->get_products();
    
    foreach ($products as $product) {
        $product_id = $product->get_id();
        $video_url = get_post_meta($product_id, '_wpp_product_video_url', true);
        
        $writer->startElement('item');
        $writer->writeElement('g:id', (string)$product_id);
        $writer->writeElement('g:title', $product->get_name());
        $writer->writeElement('g:description', wp_strip_all_tags($product->get_short_description() ?: $product->get_description()));
        $writer->writeElement('g:link', $product->get_permalink());
        
        $image_id = $product->get_image_id();
        if ($image_id) {
            $writer->writeElement('g:image_link', wp_get_attachment_image_url($image_id, 'full'));
        }
        
        $writer->writeElement('g:price', $product->get_price() . ' ' . get_woocommerce_currency());
        $writer->writeElement('g:availability', $product->is_in_stock() ? 'in_stock' : 'out_of_stock');
        $writer->writeElement('g:condition', 'new');
        
        // Append video_link when configured on the product record
        if (!empty($video_url) && filter_var($video_url, FILTER_VALIDATE_URL)) {
            $writer->writeElement('g:video_link', esc_url_raw($video_url));
        }
        
        $writer->endElement(); // item
    }
    
    $writer->endElement(); // channel
    $writer->endElement(); // rss
    $writer->endDocument();
    
    $writer->flush();
    exit;
}

Once published, flush your rewrite rules by opening Settings, then Permalinks, in WordPress and saving. The feed will resolve reliably at example.com/feed/google-merchant-video-en/.

#How long Google Merchant Center takes to process a product video

The video_link attribute is recent. Google announced it in its 2026 specification update (Merchant Center product data specification update 2026): merchants could submit videos at once, technical validation errors were reported from 14 April 2026, and serving together with policy and quality checks started on 30 June 2026. A feed that sent video_link before that date saw no video serving at all, which looked like a stuck queue but was the planned rollout.

For later updates the attribute’s help page gives two figures. When a video is replaced under a new, unique URL, Google typically recrawls within 24 to 72 hours, the product shows as “Under review”, and the previous video keeps serving in the meantime. When the file changes under the same URL, the change can take up to six weeks to be picked up.

Issues with videos are listed in the “Needs attention” section of the Merchant Center account. Policy or quality errors stop the video from serving, but according to Google they do not affect the serving of the offer itself, so a rejected video does not disapprove the product.

Stores that send products through an API rather than a fetched XML file have a second deadline. The Content API for Shopping reached sunset on 18 August 2026; from 1 September 2026 requests without an approved extension fail intermittently with HTTP 410, and full shutdown is planned for early 2027 (Deprecation and sunset). A plugin that still calls the old API can lose video updates for that reason alone, so check which API your feed integration uses before blaming the file. A feed that Merchant Center fetches from a URL, like the one above, does not go through the Content API.

#How to create a dedicated video sitemap for WooCommerce products

Beyond the merchant-specific catalog feed, search engines rely on a Google Video Sitemap to index product media across general search tabs, video aggregators, and Google Discover carousels.

A valid video sitemap implements the xmlns:video="http://www.google.com/schemas/sitemap-video/1.1" namespace. Mandatory properties include <video:thumbnail_loc>, <video:title>, <video:description>, and either <video:content_loc> for direct MP4 assets or <video:player_loc> for hosted players.

Here is a standalone feed generator for WooCommerce video sitemaps:

<?php
/**
 * Dedicated Google Video Sitemap feed generator for WooCommerce.
 */
declare(strict_types=1);

if (!defined('ABSPATH')) {
    exit;
}

add_action('init', 'wpp_register_en_video_sitemap');

function wpp_register_en_video_sitemap(): void
{
    add_feed('video-sitemap-en.xml', 'wpp_render_en_video_sitemap');
}

function wpp_render_en_video_sitemap(): void
{
    header('Content-Type: application/xml; charset=UTF-8');
    
    $writer = new XMLWriter();
    $writer->openURI('php://output');
    $writer->startDocument('1.0', 'UTF-8');
    $writer->setIndent(true);
    
    $writer->startElement('urlset');
    $writer->writeAttribute('xmlns', 'http://www.sitemaps.org/schemas/sitemap/0.9');
    $writer->writeAttribute('xmlns:video', 'http://www.google.com/schemas/sitemap-video/1.1');

    $products = wc_get_products([
        'status' => 'publish',
        'limit' => 500,
        'meta_key' => '_wpp_product_video_url',
        'meta_compare' => 'EXISTS',
    ]);

    foreach ($products as $product) {
        $product_id = $product->get_id();
        $video_url = get_post_meta($product_id, '_wpp_product_video_url', true);
        
        if (empty($video_url)) {
            continue;
        }

        $thumbnail_id = $product->get_image_id();
        $thumbnail_url = $thumbnail_id ? wp_get_attachment_image_url($thumbnail_id, 'full') : '';
        if (empty($thumbnail_url)) {
            continue;
        }

        $writer->startElement('url');
        $writer->writeElement('loc', $product->get_permalink());
        
        $writer->startElement('video:video');
        $writer->writeElement('video:thumbnail_loc', esc_url($thumbnail_url));
        $writer->writeElement('video:title', esc_html($product->get_name()));
        $writer->writeElement('video:description', esc_html(wp_strip_all_tags($product->get_short_description() ?: $product->get_name())));
        
        if (preg_match('~(?:youtube\.com/watch\?v=|youtu\.be/)([\w-]{11})~', $video_url, $yt)) {
            $writer->writeElement('video:player_loc', 'https://www.youtube.com/embed/' . $yt[1]);
        } else {
            $writer->writeElement('video:content_loc', esc_url($video_url));
        }

        $writer->writeElement('video:publication_date', get_the_date('c', $product_id));
        $writer->writeElement('video:family_friendly', 'yes');
        $writer->endElement(); // video:video
        
        $writer->endElement(); // url
    }

    $writer->endElement(); // urlset
    $writer->endDocument();
    
    $writer->flush();
    exit;
}

Submit example.com/video-sitemap-en.xml in Google Search Console so that Google Search can discover the product videos.

#How to prevent Cloudflare and CDNs from blocking Googlebot-Video

Even when video containers and XML feeds adhere strictly to standards, edge caching policies and firewall rules may quietly terminate crawler sessions.

Prominent Content Delivery Networks, especially Cloudflare, incorporate automated bot mitigation heuristics:

1. Bot Fight Mode: Tracks TLS fingerprints, missing browser headers, and rapid sequential requests. Because Googlebot-Video employs distinct network characteristics compared to standard Googlebot HTML crawlers, automated heuristics often trigger JavaScript challenges or HTTP 403 blocks.
2. Hotlink Protection Rules: Verifies the Referer request header. Media crawlers do not include client referrers, which causes hotlink modules to deny requests.
3. Byte-Range Caching: Certain caching rules ignore incoming Range headers, attempting to cache the entire video object before responding. If origin latency exceeds thresholds, the connection times out.

To configure an airtight exception rule in Cloudflare WAF, create a Custom Rule that explicitly permits verified search crawler requests for media extensions:

(cf.client.bot and http.request.uri.path contains "/wp-content/uploads/" and (http.request.uri.path.extension in {"mp4" "webm" "mov"})) or (http.user_agent contains "Googlebot-Video" and cf.client.bot)

Configure this rule action as Skip, skipping WAF managed rules, Super Bot Fight Mode and rate limiting for matching requests. Super Bot Fight Mode comes with the Pro, Business and Enterprise plans, and Cloudflare documents that custom rules with Skip run before it (Super Bot Fight Mode). The free Bot Fight Mode behaves differently: Cloudflare states that it cannot be bypassed or skipped with WAF custom rules or Page Rules, and that Skip, Bypass and Allow have no effect on it (Bot Fight Mode). On the free plan the options are to switch Bot Fight Mode off or to add an IP Access rule, which is evaluated first.

On your origin Nginx web server, verify that byte ranges stream cleanly using kernel-level zero-copy operations:

location ~* \.(mp4|webm|m4v)$ {
    # Permit multi-range streaming queries
    max_ranges 100;
    
    # Declare explicit byte range acceptance
    add_header Accept-Ranges bytes always;
    add_header Access-Control-Allow-Origin "*" always;
    add_header Cache-Control "public, max-age=31536000, immutable";
    
    # Kernel-level direct file streaming
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    
    expires 365d;
    access_log off;
}

This configuration ensures the Linux kernel delivers video chunks directly from file storage to network buffers without unnecessary PHP or proxy overhead.

#How to check that a request really comes from Googlebot-Video

Before you open a firewall exception, confirm in the access log that the blocked requests are Google’s. Google’s crawler documentation (Google’s common crawlers) lists Googlebot-Video with the robots.txt token Googlebot-Video and the user agent Googlebot-Video/1.0, and warns that a user agent string can be faked. A matching name proves nothing on its own.

Two checks do. A reverse DNS lookup of the IP must return a hostname in googlebot.com (of the form crawl-***-***-***-***.googlebot.com or geo-crawl-***-***-***-***.geo.googlebot.com), and a forward lookup of that hostname must return the same IP. Alternatively, the IP must fall within the ranges Google publishes in common-crawlers.json.

host 66.249.66.1
host crawl-66-249-66-1.googlebot.com

The same page says that rules set for the Googlebot-Video token apply to video features in Search and to other products that depend on videos. A robots.txt that disallows /wp-content/uploads/ for every agent therefore also hides self-hosted product videos, and the Merchant Center help page explicitly requires that robots.txt does not block the video URL. Check the live file before you change anything at the CDN:

curl -s https://example.com/robots.txt | grep -i -A5 "user-agent"

#How to inspect HTTP headers and range requests with curl and ffprobe

Before re-triggering feed ingestion in Merchant Center, verify your server responses via CLI commands.

Step 1: Test byte range handling using curl with a simulated Googlebot-Video user agent:

curl -I -X GET \
  -H "User-Agent: Googlebot-Video/1.0" \
  -H "Range: bytes=0-1024" \
  https://example.com/wp-content/uploads/product-sample.mp4

A healthy response must return:

• Status code: HTTP/2 206 or HTTP/1.1 206 Partial Content.
• Header: Accept-Ranges: bytes.
• Header: Content-Range: bytes 0-1024/TOTAL_BYTE_SIZE.
• Header: Content-Type: video/mp4.

Receiving 200 OK, 403 Forbidden, or redirect codes indicates that your edge or server stack is rejecting partial stream requests, which inevitably causes Merchant Center processing to hang.

Step 2: Inspect remote container atom ordering with ffprobe:

ffprobe -v trace -show_packets https://example.com/wp-content/uploads/product-sample.mp4 2>&1 | head -n 40

Confirming type:'moov' near the top lines indicates that the faststart flag is active. If type:'mdat' appears first, remux the container prior to catalog ingestion.

#Frequent questions about video processing in Google Merchant Center

To clarify ongoing management choices, consider these practical trade-offs:

1. Is YouTube hosting better than self-hosted MP4 files for Merchant Center Hosting product videos on YouTube is technically the most reliable route for Google Merchant Center. It eliminates origin hosting costs, bandwidth limits, and edge firewall issues. However, self-hosting MP4 files through Cloudflare Stream or specialized media CDNs gives your brand full control over player styling, removes competitor recommendation cards, and keeps customer focus strictly on your checkout flow.

2. How long should normal video processing take in Google Merchant Center Google’s help gives 24 to 72 hours for a recrawl after a video moves to a new URL and up to six weeks when the file changes under the same URL. A video that stays unserved well past that window, with nothing listed under “Needs attention”, points to a fetch problem: a blocked request, a redirect, or a URL that returns a page instead of the file.

3. Should I change the video URL after modifying an MP4 file on the server Yes. Google’s help asks for a new, unique URL when a video is replaced, because a change under the same URL can take up to six weeks to be noticed. A new file name such as product-v2.mp4 is the cleanest way to do it.

By standardizing video files with faststart, ensuring support for HTTP 206 range requests, and maintaining strict schema parity between feeds and product templates, store owners can eliminate stuck processing and capture prominent visibility in Google Shopping.