Shoppable CTV Needs a Sell-Side SKU Graph: How Product-Aware Auctions Unlock Real Commerce Outcomes

Introduction

Shoppable CTV has moved from novelty to momentum. Platforms have proven that living room commerce works when the path to checkout is simple and the product being shown is clearly in stock, correctly priced, and relevant to the moment. Roku has demonstrated native checkout and Action Ads with partners like Shopify, Walmart, and others, turning the remote into a purchase device and closing the loop on TV commerce in a way linear never could :cite[ekx,drk,ch7]. Amazon has introduced remote-enabled, add-to-cart shoppable formats inside Prime Video that avoid QR-code gymnastics and push directly to cart :cite[ctt,cu0,c7c]. These wins are encouraging. Yet they largely live inside walled ecosystems with vertically integrated data and UX control. In the broader, multi-publisher, multi-SSP CTV marketplace, we still lack a foundational capability: a standard, supply-side representation of product entities that the auction can understand at bid time. This article argues that shoppable CTV needs a sell-side SKU graph to scale. By making auctions product-aware, the supply side can route ads to the right impression opportunities, reduce wasted spend on out-of-stock items, enable product-level pacing and frequency, and activate closed-loop measurement with privacy-by-design. As a company focused on supply-side intelligence for web, app, and CTV, Red Volcano sees this as a strategic unlock for SSPs, publisher networks, and commerce-forward media owners. A SKU graph on the sell side is not just a data asset. It is the connective tissue that aligns content signals, commerce catalogs, and bid decisions in real time.

What Is a Sell-Side SKU Graph?

A sell-side SKU graph is a normalized, privacy-safe representation of product entities and offer states made available to the auction. It unifies the many attributes that matter for commerce outcomes and ties them to the impression opportunity. At its core, a SKU graph is an entity resolution and enrichment layer that maps:

Product identity: Brand, model, variant, GTIN/UPC, MPN, SKU, canonical product URL, images
Offer details: Merchant of record, price, currency, promotions, availability, shipping constraints
Classification: IAB Ad Product Taxonomy nodes, brand category, GS1 category, retailer category mapping
Contextual linkage: Page/app context, scene-level metadata, CTV episode moment, device and region constraints
Commerce outcomes: Historical conversions, post-view add-to-cart, coupon redemption, store-level pickup

This graph is not buyer first-party data. It is not identity about people. It is product-level ground truth expressed in a way the sell side can use to:

Validate that the advertised product is in stock in the viewer’s region
Prioritize creative and deal IDs that are compatible with the current impression and device UX
Route inventory to buyers with intent to promote the specific SKUs available
Measure commerce outcomes through clean-room or aggregated event pipelines without exposing PII

Why the Auction Must Become Product-Aware

Most programmatic infrastructure understands placements, content, and audiences. It does not understand products. That gap produces friction in shoppable CTV:

Out-of-stock waste: Bids clear for SKUs that cannot be purchased in the viewer’s region or are unavailable. Every wasted impression is a poor UX and poor ROAS.
Mismatched creative: The ad creative may show a variant or price that does not match current offers. This erodes trust before the checkout flow begins.
No product-level pacing: Budgets and frequency are managed at campaign or creative level. SKU-level controls would align supply availability with buyer demand.
Thin measurement signal: Without structured product identifiers in the bidstream, post-campaign commerce reporting is stitched together with brittle heuristics.

Walled gardens solve this by holding product catalog, shoppable UX, and auction logic under one roof. For the open CTV ecosystem to compete, the sell side must standardize product entities at the impression level so buyers can reliably optimize for commerce outcomes.

The State of Shoppable CTV Today

We have strong signals that viewers will buy when friction is low.

Roku and Shopify have announced remote-enabled checkout experiences for Shopify merchants and expanded shoppable functionality that shortens the path to purchase :cite[ekx,drk,bpe].
Walmart and Roku collaborated on shoppable ads that let viewers purchase Walmart items directly via their Roku devices :cite[ch7].
NBCUniversal’s ShoppableTV pioneered the QR-code call to action to drive viewers from linear and CTV content to ecommerce experiences :cite[d0k,b8n,a41].
Amazon Prime Video introduced add-to-cart with the remote and other interactive formats embedded inside the streaming UI, advancing beyond QR-only flows :cite[ctt,cu0,bpp].

These innovations confirm that the living room is a viable commerce surface. But they also highlight fragmentation. Each platform defines its own product metadata, checkout method, and measurement approach. The open programmatic ecosystem needs a neutral, sell-side layer to translate product truth into the auction.

The Standards We Have - And The Gap We Need To Fill

The industry does have building blocks:

OpenRTB 2.6 added rich support for CTV, channel and pod modeling, and other features that make CTV buying more precise :cite[d3c,aqe,a37].
Sellers.json and ads.txt/app-ads.txt increase supply chain transparency and reduce spoofing, especially important in CTV where app store verification matters :cite[d1e,as1,iln,elo].
IAB Tech Lab Ad Product, Content, and Audience taxonomies provide common language for product categories and audience context signals :cite[bqr,elq,b0v].
Seller Defined Audiences - now positioned as Curated Audiences - enables privacy-respectful first-party audience packaging at the seller side :cite[bfd,csd,dk9].
Open Measurement SDK for CTV brings standardized viewability and verification signals into CTV environments :cite[dse,bzm,fmi].
Global Privacy Platform standardizes the consent and privacy signal handling across channels, including CTV :cite[g7b,bzw,atv].

What is missing is a standardized, privacy-safe representation of product entities at auction time. There is no first-class “product” object in OpenRTB 2.x today. The closest we get are taxonomies for categories and seller-defined audience constructs. For shoppable CTV to scale, we need a repeatable approach to express GTIN or SKU-level facts into bid requests or at least into agreed extensions.

Defining The Sell-Side SKU Graph

A SKU graph should be built on identifiers that travel and validate cleanly:

GS1 identifiers: GTIN-12, -13, -14 are global product identifiers widely used across retail and commerce, and even appear in schema.org Product markup :cite[ffc,dsw,ifr].
Merchant-specific SKU: The retailer’s SKU is essential for inventory state and price. It must map to GTIN and brand-level entities.
Brand canonicalization: Normalize brand strings and model names to a canonical brand registry to handle misspellings, abbreviations, and legacy names.
Offer metadata: Price, promotions, shipping constraints, region availability, and pickup options change frequently, which requires low-latency refreshes.

On the sell side, the graph links impression opportunity to candidate products by matching:

Contextual relevance: Episode, scene, or content node relevant to the product category
Device and UX constraints: Remote-enabled purchase, QR flows, second-screen handoff
Geography and compliance: Shipping availability, legal constraints, regional merchandising
Buyer deal targeting: Deal IDs and seat restrictions for retail media partners and advertisers

Architecture Blueprint: Product-Aware Auctions

Below is a high-level architecture for adding product awareness to the auction using a sell-side SKU graph.

1) Data Ingestion and Normalization

Feed ingestion: OAuth or SFTP from retailer PIM or merchant platforms such as Shopify, BigCommerce, and Google Merchant Center.
Schema alignment: Map feeds to a unified schema that supports GTIN, SKU, price, availability, brand, category, and regional constraints.
Entity resolution: Fuzzy brand and model matching to canonical brand table; GTIN validation using GS1 rules; SKU-to-GTIN linkage.
Offer freshness: Incremental updates with sub-10-minute latency for price and in-stock fields. Use compact deltas to keep memory caches fresh.

Example SQL-like pseudocode for brand normalization:

-- Simplified brand normalization with confidence scoring
WITH candidates AS (
SELECT
p.raw_brand,
b.canonical_brand,
SIMILARITY(p.raw_brand, b.alias) AS score
FROM product_feed p
JOIN brand_alias b
ON p.raw_brand % b.alias  -- trigram similarity operator
)
, ranked AS (
SELECT
raw_brand,
canonical_brand,
score,
ROW_NUMBER() OVER (PARTITION BY raw_brand ORDER BY score DESC) AS r
FROM candidates
)
SELECT raw_brand, canonical_brand, score
FROM ranked
WHERE r = 1 AND score >= 0.75;

2) Graph Storage and Access

Storage: Use a hybrid model. Columnar store for feed snapshots and historical price. In-memory key-value for hot offer lookup. Optional graph DB for relationships.
APIs: gRPC or REST for low-latency lookups keyed by GTIN, SKU, or brand-model composites. Support batch queries to minimize hops per impression.
Caching strategy: Co-locate caches with edge auction services. TTL tuned per attribute - seconds for availability, minutes for price, days for images.
Privacy posture: No PII collection. Treat product and offer metadata as non-personal data. Align consent signaling with IAB GPP for any downstream measurement.

3) Auction Integration

OpenRTB extensions: Until a formal product object exists, use a namespaced ext in bid requests and deals to signal product eligibility and intent.
Prebid key-values: For web or app environments using Prebid, key-value targeting can carry SKU graph selectors to the ad server and header bidding stack.
Creative templating: Render dynamic price and availability in the ad creative only after the SKU graph confirms freshness. Fail gracefully if stale.
Outcome routing: Pass structured product identifiers into measurement beacons and clean-room inputs to attribute add-to-cart or buy-now actions.

4) Measurement and Verification

OM SDK for CTV: Use OM SDK signal coverage for CTV to validate viewability and reduce invalid traffic risks within shoppable formats :cite[dse,bzm].
Post-transaction callbacks: For remote-enabled purchase flows, capture an additive, aggregated event stream with GTIN or SKU as the join key.
Clean rooms: Join aggregated impression-exposure tables to aggregated transaction tables with product keys, not user identifiers. Respect GPP signals :cite[g7b,bzw].

Example: OpenRTB 2.6 With Product-Aware ext

While OpenRTB 2.6 does not define a product object, you can pass product intent and eligibility via a seller-scoped extension. Below is a conceptual example.

{
"id": "req-123",
"imp": [{
"id": "1",
"video": {
"w": 1920,
"h": 1080,
"mimes": ["video/mp4"],
"pos": 1
},
"ext": {
"rv_sku": {
"eligibility": {
"device_remote_enabled": true,
"qr_supported": true,
"second_screen_supported": true
},
"context": {
"content_taxonomy": ["IAB1-7"],
"brand_safety": ["G"]
},
"sku_graph": {
"candidate_products": [{
"gtin": "00012345600012",
"merchant_sku": "ABC-XL-NAVY",
"brand": "ExampleCo",
"category_ad_product_taxonomy": "Clothing > Activewear > Hoodies",
"price": {"value": 59.99, "currency": "USD"},
"availability": "in_stock",
"region": ["US-CA","US-NY"],
"merchant_of_record": {
"domain": "retailer.example",
"seller_id": "12345",
"sellers_json_url": "https://retailer.example/sellers.json"
},
"ttl_seconds": 300
}]
}
}
}
}],
"site": {
"domain": "ctvapp.example",
"page": "app://channel/episode/123"
},
"device": {
"ifa": "0000-0000-0000-0000",
"ua": "Roku/DVP-12.0",
"geo": {"country": "USA", "region": "CA"}
},
"regs": {
"ext": {"gpp": "DBABTA~CPXx...", "gpp_sid": [2,7]}
}
}

Buyers that understand the rv_sku extension can tailor bids and creatives to the verified in-stock product. Others can ignore it without breaking.

Example: Prebid Key-Values For Shoppable Placements

For environments where header bidding is used, you can pass SKU graph context as ad server targeting keys.

pbjs.setConfig({
ortb2: {
site: {
pagecat: ["IAB1-7"]
},
user: {
data: [{
name: "rv_sku",
segment: [
{name: "gtin", value: "00012345600012"},
{name: "merchant_sku", value: "ABC-XL-NAVY"},
{name: "availability", value: "in_stock"},
{name: "region", value: "US-CA"}
]
}]
}
}
});

The ad server can then match deal IDs that expect these keys and route demand accordingly.

Entity Resolution: From Messy Feeds To Clean Product Truth

Product feeds are messy. Sellers may omit GTINs, use inconsistent brand names, or conflate color and size variations. You will need a robust resolution pipeline.

GTIN validation: Enforce length and checksum rules per GS1 standards; reject or quarantine invalid identifiers :cite[ffc,br9].
Schema.org enrichment: Crawl canonical product pages and read schema.org Product metadata to backfill missing GTIN or brand when available :cite[ifr,dsw].
Variant grouping: Group IndividualProduct variants by ProductModel to avoid duplicate auctions that fragment pacing across colors and sizes.
Conflict resolution: Prioritize merchant feeds for price, brand registry for naming, and crowd truth for images. Score sources and version changes.

Example JSON schema sketch for the SKU graph:

{
"product": {
"id": "prod_9a12",
"gtin": "00012345600012",
"brand": "ExampleCo",
"model": "HoodiePro",
"taxonomy": {
"iab_ad_product": "Clothing > Activewear > Hoodies",
"gs1_gpc": "10004294"
}
},
"offer": {
"merchant_domain": "retailer.example",
"merchant_sku": "ABC-XL-NAVY",
"price": {"value": 59.99, "currency": "USD"},
"availability": "in_stock",
"regions": ["US-CA","US-NV"],
"last_updated": "2025-09-07T15:20:00Z"
},
"media": {
"image_url": "https://cdn.example/img/hoodiepro-navy.png",
"product_url": "https://retailer.example/p/hoodiepro/navy-xl"
}
}

Product-Aware Auction Logic

Once the SKU graph is available at the sell side, auction logic can evolve.

Eligibility filtering: Before calling demand, filter out products that are out-of-stock in the viewer’s region or restricted by device UX.
Creative selection: Rank creatives that match the confirmed price and variant. Fall back to generic brand creative if freshness cannot be verified.
Deal routing: Match impression to retail media deals tied to specific GTINs or categories and allocate supply accordingly.
SKU-level pacing: Introduce per-SKU pacing and caps to avoid overserving scarce inventory, a common issue in retailer promotions.

Illustrative pseudo-code:

def prepare_shoppable_callout(imp, device, geo):
candidates = sku_graph.lookup(context=imp.context, geo=geo)
eligible = [c for c in candidates if c.availability == "in_stock" and c.region_allows(geo)]
if not eligible:
return None  # no shoppable callout
selected = rank_by_relevance(eligible, imp, device)
return {
"gtin": selected.gtin,
"merchant_sku": selected.merchant_sku,
"price": selected.price,
"ext": build_rv_sku_ext(selected, device)
}

Privacy And Compliance By Design

A SKU graph should operate without handling personal data. Still, commerce outcomes may require consent-aware signaling.

Non-PII core: Product and offer metadata are non-personal. Keep the SKU graph segregated from user identifiers and audience stores.
Consent propagation: Use the Global Privacy Platform fields in OpenRTB regs.ext to indicate applicable privacy regimes and user choices :cite[g7b,bzw].
Aggregated measurement: Attribute outcomes using aggregated product-level joins in a clean room, not raw user-level data. Report lift and ROAS at SKU or category tiers.

How This Improves Buyer And Seller Outcomes

A product-aware auction benefits both sides of the trade.

Reduced waste: Fewer impressions for out-of-stock or mispriced items. Higher probability that engagement leads to conversion.
Better UX: Fewer jarring price mismatches or dead-end flows. Trust improves when the ad reflects reality.
New deal types: Retail media buyers can negotiate GTIN-scoped deals and guarantee that eligible supply will be curated accordingly.
Closed-loop proof: Structured product identifiers allow robust, privacy-safe attribution and learning loops that feed future bidding.

Implementation Considerations For SSPs And Publishers

Bringing a SKU graph into production takes discipline in data engineering and productization.

Data Engineering

Cadence: Price and availability need fast deltas. Design for sub-10-minute propagation from merchant system to edge cache.
Scale: Expect tens of millions of product rows across multiple merchants. Pre-compute regional slices to speed lookup.
Resilience: Fail gracefully when feeds lag. Prefer generic brand creative or disable shoppable UX rather than risk a broken purchase flow.
Auditability: Keep versioned snapshots to reconstruct what the auction “knew” at impression time for dispute resolution.

Product And UX

UX modes: Support remote add-to-cart, QR code handoff, and second-screen syncing. Choose mode dynamically based on device capabilities.
Accessibility: Ensure readable overlays and straightforward CTA copy. Accessibility wins matter on the largest screen in the home.
Publisher fit: Work with editorial to establish commerce-safe content zones and reject shoppable overlays where they degrade experience.

Commercial Packaging

SKU-curated PMPs: Offer PMPs tied to specific GTIN sets or categories with SKU-level pacing and caps.
Retail media bundles: For retailers with media networks, create co-branded shoppable packages with guaranteed eligibility and attribution.
Outcome pricing: Experiment with vCPM plus add-to-cart bonuses or cost-per-checkout trials where the UX supports deterministic handoff.

Where Red Volcano Fits

Red Volcano specializes in supply-side intelligence for web, app, and CTV. A sell-side SKU graph aligns naturally with our core:

Publisher and app intelligence: We already map technologies, SDKs, and commerce capabilities across the supply landscape. We can score which publishers and CTV apps are shoppable-ready based on device support, app store metadata, and SDK signals.
Sellers.json and ads.txt monitoring: We can stitch merchant-of-record and seller relationships into the graph to avoid supply chain ambiguity and equip buyers with transparency :cite[d1e,as1].
CTV data platform: Our CTV data products can host eligibility lookups at the edge, aligning content metadata with product entities in real time.
Outreach services: We can help SSPs and publishers operationalize SKU graph onboarding with commerce partners and merchant integrations.

A Red Volcano SKU Graph module would:

Normalize GTIN, brand, and SKU across retailers using GS1 and schema.org conventions :cite[ffc,ifr].
Expose low-latency APIs and OpenRTB extensions for product-aware auctions.
Verify merchant relationships using sellers.json and app-ads.txt cross checks to limit spoofing and reduce downstream disputes :cite[d1e,iln].
Measure with aggregated, product-level clean-room joins and OM SDK consistency checks :cite[dse,bzm].

Potential Standardization Path

To scale beyond proprietary extensions, the industry could consider a formal working item in IAB Tech Lab:

OpenRTB Product Object: Define a lightweight, optional object for product identity and offer state, including GTIN, SKU, price, availability, and merchant-of-record.
Taxonomy alignment: Reference IAB Ad Product Taxonomy for category and GS1 for product identity. Avoid buyer-specific fields that expose competitive data :cite[bqr,ffc].
Privacy and fraud posture: Clarify that product objects contain no PII, and include alignment with GPP and OM SDK for measurement and compliance :cite[g7b,dse].
Interoperability: Provide migration guidance for ext namespaces and recommended fallbacks so non-participating buyers are not broken.

OpenRTB 2.6 already proves we can evolve the protocol for CTV needs. A product object is a natural next step if the community wants shoppable to flourish in the open ecosystem :cite[d3c,aqe].

Risks And Mitigations

Introducing product awareness to the auction brings predictable risks.

Data quality: Inconsistent feeds and missing GTINs can degrade accuracy. Mitigation - invest in entity resolution, schema.org enrichment, and source scoring.
Coverage gaps: Not all merchants can integrate on day one. Mitigation - start with anchor verticals and retailers, then expand by using proxy signals and affiliate data.
Latency: Real-time eligibility lookups can slow callouts. Mitigation - co-locate caches, pre-compute regional slices, and use compact deltas.
Competitive fast-follow: Others will build similar graphs. Mitigation - differentiate with coverage, freshness SLAs, and measurement fidelity.
UX friction: Poorly implemented overlays will turn viewers off. Mitigation - strict design guidelines, device-aware mode selection, and publisher veto power.

KPIs To Track

Measure what matters for commerce outcomes and platform reliability.

Eligibility hit rate: Percent of impressions with at least one in-stock product candidate for the viewer’s region.
OOS deflection: Reduction in bids served to out-of-stock products vs baseline.
Add-to-cart rate: Lift in add-to-cart or buy-now events when SKU graph is active.
Creative consistency: Percentage of impressions where price and variant in creative match the SKU graph.
Latency: 99th percentile time to respond for SKU eligibility API.
Measurement integrity: Share of impressions with OM SDK coverage and valid GPP signals :cite[dse,g7b].

A Sample Merchant Integration Flow

To illustrate the path from a merchant’s product feed to a product-aware auction:

Merchant grants access to product feed via OAuth or SFTP.
Red Volcano SKU Graph pipeline validates GTINs, normalizes brand, and maps SKUs to GTIN and taxonomy.
Availability and price updates stream as incremental deltas to regional edge caches.
Publisher or SSP configures shoppable placements, device capabilities, and safe content zones.
At bid time, the auction queries the local cache for eligible SKUs for the viewer’s geo and device.
OpenRTB request includes rv_sku ext with candidate product metadata.
Buyer returns creative variant with matching price and variant.
OM SDK and GPP signals ensure measurement validity and consent.
Conversion callbacks send aggregated SKU-level outcomes to a clean room for attribution.
Beyond CTV: Web And Mobile App

Although this article focuses on CTV, the SKU graph can unify experiences across web and mobile apps:
- Consistent product truth: The same product eligibility and pricing logic powers web hero units, in-feed shoppable placements, and CTV Action Ads.
- Cross-surface pacing: SKU-level pacing can allocate inventory across surfaces more rationally than creative-level caps.
- Unified reporting: Product-level outcomes roll up across channels for retailers and brands seeking consolidated commerce media KPIs.
Conclusion

Shoppable CTV works when the product experience is accurate, the checkout is native, and the auction respects the realities of inventory and price. Walled ecosystems have a head start because they control those variables end to end. The open CTV ecosystem will only catch up if the sell side becomes product-aware. A SKU graph gives publishers and SSPs the product truth they need to route demand, protect user experience, and prove outcomes at scale. It aligns the exchange of ad impressions with the exchange of goods by making the product a first-class citizen in the auction. For Red Volcano and our customers, this is squarely in our lane. We already map the supply side. The next chapter is mapping the products that make shoppable CTV work everywhere.

References
- Roku and Shopify - checkout on TV and Action Ads context: :cite[ekx,drk,bpe]
- Walmart and Roku - shoppable partnership: :cite[ch7]
- NBCU ShoppableTV - QR-based shoppable experiences: :cite[d0k,b8n,a41]
- Amazon Prime Video - remote-enabled shoppable ad formats: :cite[ctt,cu0,c7c,bpp]
- IAB Tech Lab - OpenRTB 2.6 and CTV enhancements: :cite[d3c,aqe,a37]
- Sellers.json and ads.txt/app-ads.txt for CTV transparency: :cite[d1e,as1,iln,elo]
- IAB Tech Lab taxonomies - Ad Product, Content, Audience: :cite[bqr,elq,b0v]
- Seller Defined Audiences - Curated Audiences overview: :cite[bfd,csd,dk9]
- Open Measurement SDK for CTV: :cite[dse,bzm,fmi]
- Global Privacy Platform - consent signaling: :cite[g7b,bzw,atv]
- GS1 GTIN and schema.org Product identifiers: :cite[ffc,dsw,ifr,br9]