E-commerce Product Video Automation by API

Since June 30, 2026, product videos that merchants submit through a new video_link attribute in the product feed have been eligible to serve in Google Merchant Center (Google Merchant Center Help, 2026). Google says linked videos "will appear in free listings, and can also be used in Google Ads campaigns" (Google Merchant Center Help, 2026). So there is now a field in the feed for a video of every SKU. For most catalogs that field stays empty, because nobody can shoot a video for every product.

This guide shows you how to fill it with a video API. You'll render a 25-second product ad (premium reveal, multiple angles, animated price, "Shop now" call to action) from a single JSON payload, wire it to your catalog so every product gets its own video, and put the result back into your Merchant Center feed. We'll cover the API path, the product-feed mapping, and the video_link rules that decide whether Google accepts the file.

Key Takeaways

• Google Merchant Center accepts up to 10 product videos per item through the optional video_link attribute, and those videos have been eligible to serve since June 30, 2026 (Google, 2026)
• Five variables (title, price and three images) produce a unique 25-second, 1920x1080 video per product, and they map straight onto Shopify and Merchant Center feed fields
• One render costs 0.41 credits: about $0.08 on pay-as-you-go, about $0.04 on the Business plan. The same 25 seconds from Veo 3.1 Lite costs $2.00 at 1080p (Google AI for Developers, 2026)
• Google requires a static link that does not expire, and a new URL each time the video changes. Plan your storage for both before you render a catalog
• The viral "product videos lift conversions 80%" and "144% more add-to-carts" stats have no study or methodology we could find, so this post doesn't use them

Why Automate Product Video at Catalog Scale?

Google's 2026 product data specification adds a video link attribute because, in Google's words, videos "can help showcase products in more detail, showing them in use or from various angles" (Google Merchant Center Help, 2026). The demand side is settled: Google built a field in the feed for it.

The supply side is where it breaks. A modern catalog isn't ten products. It's hundreds to tens of thousands of SKUs, refreshed every season. Shopify's annual report puts the gross merchandise volume on its platform at $378.4 billion for 2025, up from $292.3 billion in 2024, from "millions of merchants from more than 175 countries" (Shopify Form 10-K, 2026). Behind that number sit millions of product pages. No catalog team can put a film crew on every SKU, so video gets rationed to the hero items and the long tail goes without.

Our finding: You've probably seen "product videos boost conversions 80%" or "shoppers are 144% more likely to add to cart after watching." We could not find a study or a methodology behind either number, so we don't repeat them. The case for catalog video in 2026 doesn't need them: Google built a feed field for it.

How Does an E-commerce Product Video API Work?

Google's video link attribute takes "a video URL", up to 10 per product (Google Merchant Center Help, 2026). Something has to produce those files at catalog scale. An e-commerce product video API does it by separating design from data: a template defines the look of your video ad once (scenes, motion, branding, timing) and the API fills its dynamic slots (title, price, product images) from your catalog at render time. One template plus your product feed produces a unique, finished video per SKU, with no editor in the loop. It's the same template-plus-data pattern behind personalized video at scale, applied to one of its highest-volume verticals. The mirror-image job, many versions of one offer rather than one video per SKU, is covered in batch-rendering social ad variants.

The pipeline has three parts. A data source (your Shopify catalog, product feed, or even a spreadsheet) supplies one row per product. A template marks certain layers as dynamic: in Renderly's system, any overlay flagged isDynamic becomes a named variable. And a render API accepts a replacements object per product and returns an MP4, notifying your app via webhook when it's done.

Why a template instead of generative AI? Product ads are a bounded-variation problem: the structure repeats, only the product data changes. Template rendering keeps every video on-brand and faithful to your actual catalog photos: no synthetic products, no hallucinated finishes, no off-brand drift across 5,000 renders. We've covered the trade-offs in depth in our template-based vs AI-generated video comparison, but for catalog marketing where every frame represents a real product you're selling, faithful-to-the-photos wins.

Inside the Template: A 25-Second Product Ad

The template this guide renders runs 750 frames at 30 fps, so 25 seconds, at 1920x1080. That fits Google's limits of 6 to 240 seconds, at least 720p, and a 16:9 ratio (Google Merchant Center Help, 2026). Here is Renderly's E-commerce Product Drop template with its default demo data:

The video moves through five scenes with a deliberate rhythm: a dark cold-open tease, a clean hero reveal of the product, a detail scene that sells the craft, an "every angle" scene showing all three shots, and a dark buy scene with the price and a "Shop now" button. The dark-light-dark structure bookends the bright showroom middle: Apple-product-page energy, restrained and premium.

When we designed this template, the per-product interface was deliberately small. Catalogs reliably have a title, a price, and a handful of images per product, and almost nothing else that's consistent across every SKU. So the template asks for exactly that and nothing more. Everything else (the tease line, the section kickers, the CTA label, the color system) is locked brand framing that stays identical across every render, so a thousand product videos all look like they came from the same studio.

Five variables control the output:

That's the whole interface. Three image URLs and two strings. If a product has fewer than three images, reuse product_image_1 for the empty slots. The large product frames letterbox each image (object-fit: contain) rather than crop it, so mismatched aspect ratios stay clean. The three small thumbnails in the every-angle scene do crop (cover), so keep the product near the center of each shot.

Step-by-Step: Rendering a Product Video with the API

One POST request renders a product video: Google's spec wants a direct link to "a raw video file" when the host isn't YouTube (Google Merchant Center Help, 2026), and an MP4 at a URL is what the render produces. You send a template ID plus a replacements object, get a job ID back immediately, and receive a webhook when the MP4 is ready. Here's the full flow against the template above. If you want the full request contract first, the JSON to video guide walks through it.

Step 1: Get an API key. Sign up at renderly.video, open Settings → API Keys, and create one. New accounts start with 5 free credits, which covers twelve renders of this template.

Step 2: Send the render request. Map your product's data to the template's variable names:

curl -X POST https://renderly.video/api/v1/renders \
  -H "Authorization: Bearer $RENDERLY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "templateId": "ecommerce-product-drop",
    "replacements": {
      "product_title": "Aera Lounge Chair",
      "price": "$1,290",
      "product_image_1": "https://cdn.yourstore.com/aera/front.png",
      "product_image_2": "https://cdn.yourstore.com/aera/detail.png",
      "product_image_3": "https://cdn.yourstore.com/aera/lifestyle.png"
    },
    "webhookUrl": "https://yourapp.com/webhooks/renderly"
  }'

The response is { "success": true, "data": { ... } }, and data holds the jobId, a status of PROCESSING and the creditsUsed. Any variable you omit keeps the template's default, which is useful while testing.

Step 3: Receive the finished video. You can poll GET /api/v1/renders/:jobId, but don't: pass webhookUrl as above (or register a persistent endpoint) and Renderly sends a render.completed event with the outputUrl the moment rendering finishes. Failed renders fire render.failed with a reason. Our guide to setting up video rendering webhooks covers signature verification and retries.

Step 4: Loop it over your catalog. In production this is a 20-line worker:

async function renderProductVideo(product) {
  const res = await fetch("https://renderly.video/api/v1/renders", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.RENDERLY_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      templateId: "ecommerce-product-drop",
      replacements: {
        product_title: product.title,
        price: product.priceFormatted,
        product_image_1: product.images[0],
        product_image_2: product.images[1] ?? product.images[0],
        product_image_3: product.images[2] ?? product.images[0],
      },
      webhookUrl: "https://yourapp.com/webhooks/renderly",
    }),
  });
  const { data } = await res.json();
  return data; // { jobId, status: "PROCESSING", creditsUsed, ... }
}

The same pattern scales from one product to your whole catalog. We've documented the batching and rate-limit approach in how to generate 1,000+ personalized videos with API automation.

How Do You Connect a Shopify or Product Feed?

Google's product data specification already carries the fields a template needs: title (required, up to 150 characters), price (required), image_link (required) and up to 10 additional_image_link values (Google Merchant product data spec, 2026). Your catalog already speaks the right language. You just have to map it. That mapping is the piece most automation tutorials skip: they stop at a hand-built spreadsheet and never touch the feed your store actually runs on.

For a Shopify store, use the GraphQL Admin API. Shopify says "The REST Admin API is a legacy API as of October 1, 2024" and that "all new public apps must be built exclusively with the GraphQL Admin API" from April 1, 2025 (Shopify, 2026). The Product object maps directly (images is deprecated, so read images through media):

If you already publish a Google Merchant Center feed, it works just as cleanly: title → product_title, price → price, image_link → product_image_1, and the first two additional_image_link values → product_image_2 / product_image_3. One catch: Merchant Center prices are numeric plus an ISO 4217 code, like 15.00 USD. Convert that to the display string you want on screen ($15.00) before you send it.

The trigger is the last piece. On Shopify, subscribe to the products/create and products/update webhooks so a new or edited product fires a render the moment it goes live. For a static catalog, a nightly job that loops the feed re-renders anything that changed (fresh price, new photos, seasonal copy) without anyone opening an editor.

How Do You Add the Video to Your Merchant Center Feed?

Google announced the optional video link attribute on April 14, 2026, and "Starting June 30, 2026 videos submitted via the video link attribute will become eligible to serve" (Google Merchant Center Help, 2026). The feed closes the loop: the same row that fed the render now carries the video. In an XML feed, wrap the URL in <g:video_link>. In a text feed, separate several URLs with commas.

Google's rules for the file, from the attribute's help page (Google Merchant Center Help, 2026):

Two of those rules shape your pipeline. First, the link must not expire, so copy each finished MP4 from the outputUrl to storage you control (your CDN or bucket) and put that URL in the feed. Second, Google says that if you change a video but keep the same URL, detection can take up to 6 weeks, while a new, unique URL typically triggers a recrawl within 3 days. So write each re-render to a new file name, for example with the price or a date in the path, rather than overwriting the old file.

Google also states that "Policy or quality errors with videos will prevent the video from serving, but will not impact the serving of the associated offer" (Google Merchant Center Help, 2026). A rejected video costs you the video, not the listing. Issues show up in the "Needs attention" section of your Merchant Center account.

What Does It Actually Cost at Catalog Scale?

Google's Gemini API prices Veo 3.1 video at $0.08 (Lite), $0.12 (Fast) or $0.40 (Standard) per second at 1080p, with no free tier (Google AI for Developers, 2026). Template rendering is priced differently. Renderly charges 1 credit per minute of output up to 1080p, billed by the second. The 25-second template is 0.42 minutes, so each render costs 0.41 credits: about $0.08 at the pay-as-you-go rate of $0.20 per credit, about $0.06 on the Creator plan ($29 for 200 credits) and about $0.04 on the Business plan ($99 for 1,000 credits).

Run the math at catalog scale. A 1,000-SKU catalog is 410 credits: $82 on pay-as-you-go, or about $41 on the Business plan, whose 1,000 monthly credits cover about 2,400 renders of this template. The same 1,000 products at 25 seconds each would cost $2,000 on Veo 3.1 Lite and $10,000 on Veo 3.1 Standard, and you would still have to check every clip for a product that looks different from the one you sell. A 10,000-SKU catalog is 4,100 credits, or $820 on pay-as-you-go.

Pay-as-you-go credits never expire, and subscription credits roll over up to twice the monthly allowance. 4K export is available on every plan at 4 credits per minute, but Google's floor is 720p, so 1080p is enough for a feed video. For the full spreadsheet treatment, including crew day rates and editing time, see our video API vs traditional production cost comparison.

Common Mistakes to Avoid

Google's minimum requirements for a feed video are a public link that Googlebot can reach, 6 to 240 seconds, at least 720p, and a 9:16, 16:9 or 1:1 ratio (Google Merchant Center Help, 2026). This template meets the last three by design. Most other failures at catalog scale aren't rendering bugs either. They're data hygiene.

1. Passing raw price numbers instead of formatted strings. The price variable is text, not a number, and the template does no currency formatting. Send "$1,290", not 1290, and not the feed's 1290.00 USD. Format the currency symbol and separators from your catalog data before the request, or one render in your batch will display a bare number.

2. Assuming every product has three images. Plenty of catalog rows have one photo. If you map product_image_2 and product_image_3 to URLs that don't exist, those scenes break. Always fall back to product_image_1 for missing slots, as the worker above does with ?? product.images[0].

3. Cropping product shots before sending them. The large frames use object-fit: contain inside rounded boxes, so they never crop a product awkwardly. Pre-cropping to a square fights the layout. Send clean catalog shots, ideally on a transparent or neutral background, and let the template frame them.

4. Putting a temporary link in the feed. Google wants a static link that doesn't expire. Copy the MP4 to your own storage first, and give every re-render a new file name so Google picks up the change in days rather than weeks.

5. Polling for status instead of using webhooks. At catalog scale, polling thousands of job IDs hammers the API and adds latency. Pass a webhookUrl and let render.completed tell you when each video is ready.

Start Rendering Product Videos Today

Thanksgiving Day 2026 is Thursday, November 26 (OPM federal holidays, 2026), so Black Friday is Friday, November 27. Render the catalog early: Google says a new video URL typically gets recrawled within 3 days. To recap:

• The slot exists: video_link videos have been eligible to serve since June 30, 2026, in free listings and Google Ads campaigns
• The interface is small: five variables (title, price, three images) produce a premium 25-second product ad
• The data is already there: Shopify and Merchant Center feed fields map straight onto template variables, so every product can trigger its own video
• The economics are absurd: 0.41 credits per video, about $0.08 at most, against $2.00 to $10.00 for the same 25 seconds of generated video

The fastest way to see it: open the E-commerce Product Drop template, swap in a real product's photos and price, and render your first video on free credits. Then wire it to your products/create webhook, copy each MP4 to your CDN, and add it to your feed as video_link. The long tail of your catalog, the part that never got a video, is now one render request per row.

On Shopify and want to see one first? Paste a product link into the free Shopify product video maker and download a 15-second vertical version with no signup.