@adcp/sdk API Reference - v10.0.1
    Preparing search index...

    Type Alias Product

    Product: { [k: string]: unknown } & (
        LegacyProductNamedFormatReference
        | ProductFormatOptionDeclarations
    ) & {
        product_id: string;
        name: string;
        description: string;
        publisher_properties: PublisherPropertySelector[];
        channels?: MediaChannel[];
        format_ids?: FormatReferenceStructuredObject[];
        format_options?: ProductFormatDeclaration[];
        placements?: Placement[];
        video_placement_types?: VideoPlacementType[];
        audio_distribution_types?: AudioDistributionType[];
        sponsored_placement_types?: SponsoredPlacementType[];
        social_placement_surfaces?: SocialPlacementSurface[];
        delivery_type: DeliveryType;
        exclusivity?: Exclusivity;
        pricing_options: PricingOption[];
        forecast?: DeliveryForecast;
        outcome_measurement?: OutcomeMeasurementDeprecated;
        delivery_measurement?: {
            vendors?: BrandReference[];
            provider?: string;
            notes?: string;
        };
        measurement_terms?: MeasurementTerms;
        performance_standards?: PerformanceStandard[];
        cancellation_policy?: CancellationPolicy;
        allowed_actions?: ProductAllowedAction[];
        reporting_capabilities: ReportingCapabilities;
        creative_policy?: CreativePolicy;
        is_custom?: boolean;
        property_targeting_allowed?: boolean;
        data_provider_signals?: DataProviderSignalSelector[];
        included_signals?: SignalListing[];
        signal_targeting_options?: ProductSignalTargetingOption[];
        signal_targeting_rules?: SignalTargetingRules;
        signal_targeting_allowed?: boolean;
        catalog_types?: CatalogType[];
        metric_optimization?: {
            supported_metrics: (
                | "clicks"
                | "views"
                | "completed_views"
                | "viewed_seconds"
                | "attention_seconds"
                | "attention_score"
                | "engagements"
                | "follows"
                | "saves"
                | "profile_visits"
                | "reach"
            )[];
            supported_reach_units?: ReachUnit[];
            supported_view_durations?: number[];
            supported_targets?: ("cost_per" | "threshold_rate")[];
        };
        vendor_metric_optimization?: VendorMetricOptimization;
        max_optimization_goals?: number;
        measurement_readiness?: MeasurementReadiness;
        conversion_tracking?: {
            action_sources?: ActionSource[];
            supported_targets?: ("cost_per" | "per_ad_spend" | "maximize_value")[];
            platform_managed?: boolean;
        };
        catalog_match?: {
            matched_gtins?: string[];
            matched_ids?: string[];
            matched_count?: number;
            submitted_count: number;
        };
        brief_relevance?: string;
        expires_at?: string;
        product_card?: {
            image?: ImageAsset;
            title?: string;
            description?: string;
            price_label?: string;
            cta_label?: string;
        };
        product_card_detailed?: {
            hero_image?: ImageAsset;
            carousel_images?: ImageAsset[];
            title?: string;
            description?: string;
            specifications?: { label: string; value: string }[];
            price_label?: string;
            cta_label?: string;
        };
        collections?: CollectionSelector[];
        collection_targeting_allowed?: boolean;
        installments?: Installment[];
        enforced_policies?: string[];
        trusted_match?: {
            context_match: boolean;
            identity_match?: boolean;
            response_types?: TMPResponseType[];
            dynamic_brands?: boolean;
            providers?: {
                agent_url: string;
                context_match?: boolean;
                identity_match?: boolean;
                countries?: string[];
                uid_types?: UIDType[];
            }[];
        };
        material_submission?: {
            url?: string;
            email?: string;
            instructions?: string;
            ext?: ExtensionObject;
        };
        ext?: ExtensionObject;
    }

    Represents available advertising inventory

    Type Declaration

    • [k: string]: unknown
    • LegacyProductNamedFormatReference
    • ProductFormatOptionDeclarations
    • product_id: string

      Unique identifier for the product

    • name: string

      Human-readable product name

    • description: string

      Detailed description of the product and its inventory

    • publisher_properties: PublisherPropertySelector[]

      SDK implementers MUST enforce singular-only at runtime: each entry uses the singular publisher_domain form; the compact publisher_domains[] form is rejected on products. Codegen toolchains (json-schema-to-typescript, quicktype, datamodel-code-generator, openapi-typescript-codegen) often flatten the allOf + $ref + not.required restriction below poorly and may drop the rejection constraint silently, emitting an unrestricted type — runtime enforcement is the safety net. Publisher properties covered by this product. Buyers fetch actual property definitions from each publisher's adagents.json and validate agent authorization. Selection patterns mirror the authorization patterns in adagents.json for consistency. The compact publisher_domains[] form is reserved for adagents.json authorized_agents[].publisher_properties[] so that buy-side traffic-and-pricing flatteners can always treat each entry as exactly one publisher.

    • Optionalchannels?: MediaChannel[]

      Advertising channels this product is sold as. Products inherit from their properties' supported_channels but may narrow the scope. For example, a product covering YouTube properties might be sold as ['ctv'] even though those properties support ['olv', 'social', 'ctv'].

    • Optionalformat_ids?: FormatReferenceStructuredObject[]

      Legacy named-format path: array of supported creative format IDs (structured format_id objects with agent_url and id). Products MUST carry format_ids, format_options, or BOTH; at least one is required. Named formats predate 3.1 and remain supported through the deprecation calendar (2027-Q4 floor / 2029-Q1 ceiling).

      Dual emission: A product MAY carry both format_ids and format_options simultaneously during the migration window. This is the recommended seller pattern — author once, SDK projects to both wire shapes via the canonical mapping registry, every buyer reads what it knows. When both are present, the two MUST refer to the SAME underlying format declaration (the format_options[i] narrows the canonical that the named format in format_ids[i] resolves to via the registry / explicit canonical field). SDKs that derive both shapes from one source guarantee this invariant; SDKs that don't MUST treat divergence as a build error and refuse to emit. Buyer rule: when both are present, prefer format_options; treat format_ids as fallback for legacy-format buyers. Non-projectable formats: when a named format has no clean 3.1+ format-option projection (no registry entry, no explicit canonical declaration on the named format, no structural match), SDKs MUST NOT emit format_options for that product — only format_ids ships, and the product remains legacy-format-only until the seller adds an explicit canonical field or files a registry entry.

    • Optionalformat_options?: ProductFormatDeclaration[]

      3.1+ format-option path: one or more inline format declarations the product accepts. Each element narrows a canonical format with parameters, slots, and platform_extensions. The 90% case is a single-element array (one canonical narrowed for the product). Multi-element use cases: a product that accepts EITHER a third-party-hosted creative (for example, externally served html5) OR an internal display_tag; a video product that accepts a hosted video_hosted upload OR a video_vast tag. Buyers pick which option they're shipping at sync_creatives time by aligning their manifest to the matching declaration's format_kind and slots.

      Products MUST carry format_ids, format_options, or BOTH; at least one is required. See format_ids description for the dual-emission contract (same underlying declaration when both are present; SDK derives one from the other; buyers prefer format_options when both are present).

      When placements[] also declare format_ids or format_options, product-level formats are the upper bound for the sellable product. Placement-level formats narrow the product-wide accepted set for that placement; they MUST NOT introduce a format the product does not accept. Buyers compute the effective accepted set for a placement as the intersection of product-level and placement-level declarations. For format options, match publisher-declared options by { publisher_domain, format_option_id }, match product-local options by format_option_id when publisher_domain is omitted, and otherwise match declarations with the same format_kind whose placement parameters narrow the product declaration. If a placement has no format declaration, it inherits the product-level formats.

    • Optionalplacements?: Placement[]

      Optional array of specific public placements within this product. Placement IDs are scoped by publisher domain. Product placements declare kind to distinguish publisher-referenced placements (publisher_ref) from seller-defined inline placements (seller_inline). Publisher-referenced placements carry publisher_domain plus placement_id and may omit name because buyers resolve the name from the publisher's adagents.json placement declarations. Seller-inline placements carry buyer-facing name directly; when publisher_domain is omitted, buyers MAY interpret the placement ID relative to the seller agent's own publisher domain only during the legacy single-publisher transition. Community-maintained fallback files are resolver/source metadata, not a distinct placement kind. Each placement MUST declare mode: 'targetable' (buyer may select the placement by PlacementRef, for example in creative assignments) or mode: 'included' (part of the public product composition but not buyer-selectable). Placement-level format declarations narrow the product-level creative contract and MUST NOT broaden it. Seller-private delivery objects, source/origin details, and ad-server mappings MUST NOT be exposed here.

    • Optionalvideo_placement_types?: VideoPlacementType[]

      Declared video placement types that may be included in this product, using IAB Tech Lab/OpenRTB 2.6 video.plcmt definitions with AdCP-native names. Use on OLV, CTV, and other video products when buyers need to distinguish instream, accompanying-content, interstitial, and standalone/no-content inventory. Aggregate products and ad-network products MAY declare multiple values. When placements[] also carry video_placement_types, this product-level array SHOULD be the union of the placement-level declarations the seller may deliver under the product. This is seller-declared discovery metadata, not independent verification of inventory quality or delivery context.

    • Optionalaudio_distribution_types?: AudioDistributionType[]

      Declared audio distribution types that may be included in this product, using IAB Tech Lab/OpenRTB 2.6 audio.feed definitions with AdCP-native names. Use on radio, streaming-audio, podcast, gaming, and other audio products when buyers need to distinguish music streaming services, FM/AM broadcast, podcasts, catch-up radio, web radio, video-game audio, and text-to-speech inventory without changing the buyer-facing channel or adagents.json property type. Aggregate products and ad-network products MAY declare multiple values. When placements[] also carry audio_distribution_types, this product-level array SHOULD be the union of the placement-level declarations the seller may deliver under the product. This is seller-declared discovery metadata, not independent verification of inventory quality or delivery context.

    • Optionalsponsored_placement_types?: SponsoredPlacementType[]

      Declared sponsored-placement types that may be included in this product, distinguishing where catalog-driven retail-media placements render on the retailer surface (sponsored search, sponsored display, or sponsored native). Use on retail-media products when buyers need to distinguish search-keyed, display, and native in-grid sponsored inventory. Aggregate products and ad-network products MAY declare multiple values. When placements[] also carry sponsored_placement_types, this product-level array SHOULD be the union of the placement-level declarations the seller may deliver under the product. This is seller-declared discovery metadata, not independent verification of inventory quality or delivery context.

    • Optionalsocial_placement_surfaces?: SocialPlacementSurface[]

      Declared social-placement surfaces that may be included in this product, distinguishing the in-app surface where social placements render (feed, stories, short_video, explore, or search). Use on social products when buyers need to distinguish feed, story, short-video, and discovery surfaces. Aggregate products and ad-network products MAY declare multiple values. When placements[] also carry social_placement_surfaces, this product-level array SHOULD be the union of the placement-level declarations the seller may deliver under the product. This is seller-declared discovery metadata, not independent verification of inventory quality or delivery context.

    • delivery_type: DeliveryType
    • Optionalexclusivity?: Exclusivity
    • pricing_options: PricingOption[]

      Available pricing models for this product

    • Optionalforecast?: DeliveryForecast
    • Optionaloutcome_measurement?: OutcomeMeasurementDeprecated
    • Optionaldelivery_measurement?: { vendors?: BrandReference[]; provider?: string; notes?: string }

      Measurement vendors and methodology for delivery metrics. The buyer accepts the declared vendors as the source of truth for the buy. When absent, buyers should apply their own measurement defaults. Senders SHOULD populate vendors (structured BrandRef array) for new implementations; the legacy provider string field is deprecated and retained for one-minor backwards compatibility.

      • Optionalvendors?: BrandReference[]

        Measurement vendors used for this product, as structured BrandRef identities. Multiple entries when multiple vendors play different roles (e.g., the ad server plus a separate viewability vendor like IAS or DV; or a retail-media seller plus a third-party retail measurement vendor like Circana or NielsenIQ). Each vendor's brand.json agents[type='measurement'] is the discovery anchor; metric definitions live on the agent's get_adcp_capabilities.measurement.metrics[] block. Distinct from performance_standards[].vendor which carries vendor identity for committed metrics with thresholds — this field carries vendor identity for the overall measurement story, including non-committed-but-reported metrics.

      • Optionalprovider?: string

        Deprecated as of this minor. Free-form measurement provider description (e.g., 'Google Ad Manager with IAS viewability', 'Nielsen DAR', 'Geopath for DOOH impressions'). New implementations SHOULD use the structured vendors field instead. Retained for one-minor backwards compatibility; removed at the next major. When both vendors and provider are present, consumers MUST use vendors for vendor identity and treat provider as informational text.

      • Optionalnotes?: string

        Additional details about measurement methodology in plain language (e.g., 'MRC-accredited viewability. 50% in-view for 1s display / 2s video', 'Panel-based demographic measurement updated monthly'). Free-form prose for context that doesn't fit the structured vendors field.

    • Optionalmeasurement_terms?: MeasurementTerms
    • Optionalperformance_standards?: PerformanceStandard[]

      Seller's default performance standards for this product: viewability, IVT, completion rate, brand safety, attention score. Buyers may propose different standards at media buy creation. When absent, no structured performance standards apply.

    • Optionalcancellation_policy?: CancellationPolicy
    • Optionalallowed_actions?: ProductAllowedAction[]

      Actions buyers may perform on buys created against this product, scoped to statuses and modes. Advisory template — the authoritative per-buy capability is available_actions[] on the buy response, which resolves modes against current buy state, account tier, and negotiated terms. Buyers SHOULD use this for pre-flight product selection ("which products let me self-serve cancel within 72hr?") and read available_actions[] for runtime decisions. The array is uniquely keyed by action — sellers MUST NOT emit two entries with the same action value. Absence means the seller has not declared a structured action surface for this product — buyers fall back to valid_actions[] on buy responses for the flat string vocabulary.

    • reporting_capabilities: ReportingCapabilities
    • Optionalcreative_policy?: CreativePolicy
    • Optionalis_custom?: boolean

      Whether this is a custom product

    • Optionalproperty_targeting_allowed?: boolean

      Whether buyers can filter this product to a subset of its publisher_properties. When false (default), the product is 'all or nothing' - buyers must accept all properties or the product is excluded from property_list filtering results.

    • Optionaldata_provider_signals?: DataProviderSignalSelector[]

      Deprecated. Legacy/non-selectable metadata for data-provider signals already bundled into or associated with this product. This field does not provide buyer-selectable options, prices, or seller activation handles. Use included_signals for non-selectable product signal metadata, or signal_targeting_options for selectable package-level signal groups.

    • Optionalincluded_signals?: SignalListing[]

      Non-selectable signal metadata for signals already included in, bundled with, or planned into this product. These signals describe what the product is; buyers do not select them in packages[].targeting_overlay.signal_targeting_groups and this field does not imply package-level signal targeting. Use signal_ref scope 'data_provider' or 'signal_source' to reference externally defined signals without redefining their name or value_type. Use signal_ref scope 'product' with name and value_type when the included signal is defined only by this product.

    • Optionalsignal_targeting_options?: ProductSignalTargetingOption[]

      Inline seller-offered signals that may be applied to packages for this product at create_media_buy time. Each entry references a named signal definition with signal_ref scope 'product' for a product-local signal option, scope 'data_provider' for an external signal definition published in adagents.json signals[] that the seller is authorized to apply, or scope 'signal_source' for a source-native signal. Product-local options define name and value_type inline; data-provider and signal-source options may omit those fields when the referenced definition or source is authoritative. Use this field when the selectable menu is product-specific, has product-specific pricing or activation handles, is the relevant subset for a brief/refine result, or should be rendered without an additional get_signals call. Wholesale products may omit this field and rely on get_signals for the selectable signal feed. Buyers select eligible signals through packages[].targeting_overlay.signal_targeting_groups when signal_targeting_rules allow; fixed/default entries are applied by the seller and echoed on the package state. Sellers MUST set signal_targeting_allowed to true whenever this field is present. Bundled, non-selectable signal metadata belongs in included_signals; legacy data_provider_signals may appear only for backwards compatibility.

    • Optionalsignal_targeting_rules?: SignalTargetingRules
    • Optionalsignal_targeting_allowed?: boolean

      Whether this product has a package-level signal_targeting_groups surface. When false (default), signals are bundled into the product terms and cannot be selected or explicitly echoed as package signal groups. When true, eligible signals from inline signal_targeting_options or from get_signals may be buyer-selected or seller-applied according to signal_targeting_rules and are represented through packages[].targeting_overlay.signal_targeting_groups. Editability is controlled by signal_targeting_rules; fixed/default-only products still set this to true when applied signal groups are echoed.

    • Optionalcatalog_types?: CatalogType[]

      Catalog types this product supports for catalog-driven campaigns. A sponsored product listing declares ["product"], a job board declares ["job", "offering"]. Buyers match synced catalogs to products via this field.

    • Optionalmetric_optimization?: {
          supported_metrics: (
              | "clicks"
              | "views"
              | "completed_views"
              | "viewed_seconds"
              | "attention_seconds"
              | "attention_score"
              | "engagements"
              | "follows"
              | "saves"
              | "profile_visits"
              | "reach"
          )[];
          supported_reach_units?: ReachUnit[];
          supported_view_durations?: number[];
          supported_targets?: ("cost_per" | "threshold_rate")[];
      }

      Metric optimization capabilities for this product. Presence indicates the product supports optimization_goals with kind: 'metric'. No event source or conversion tracking setup required — the seller tracks these metrics natively.

      • supported_metrics: (
            | "clicks"
            | "views"
            | "completed_views"
            | "viewed_seconds"
            | "attention_seconds"
            | "attention_score"
            | "engagements"
            | "follows"
            | "saves"
            | "profile_visits"
            | "reach"
        )[]

        Metric kinds this product can optimize for. Buyers should only request metric goals for kinds listed here. DEPRECATED values (slated for removal at next major): attention_seconds and attention_score — declare vendor-attested attention/quality metrics via vendor_metric_optimization.supported_metrics[] with an explicit vendor binding instead. Sellers MAY reject the deprecated values with TERMS_REJECTED and a suggestion to use the vendor_metric kind.

      • Optionalsupported_reach_units?: ReachUnit[]

        Reach units this product can optimize for. Required when supported_metrics includes 'reach'. Buyers must set reach_unit to a value in this list on reach optimization goals — sellers reject unsupported values.

      • Optionalsupported_view_durations?: number[]

        Video view duration thresholds (in seconds) this product supports for completed_views goals. Only relevant when supported_metrics includes 'completed_views'. When absent, the seller uses their platform default. Buyers must set view_duration_seconds to a value in this list — sellers reject unsupported values.

      • Optionalsupported_targets?: ("cost_per" | "threshold_rate")[]

        Target kinds available for metric goals on this product. Values match target.kind on the optimization goal. Only these target kinds are accepted — goals with unlisted target kinds will be rejected. When omitted, buyers can set target-less metric goals (maximize volume within budget) but cannot set specific targets.

    • Optionalvendor_metric_optimization?: VendorMetricOptimization
    • Optionalmax_optimization_goals?: number

      Maximum number of optimization_goals this product accepts on a package. When absent, no limit is declared. Most social platforms accept only 1 goal — buyers sending arrays longer than this value should expect the seller to use only the highest-priority (lowest priority number) goal.

      1

    • Optionalmeasurement_readiness?: MeasurementReadiness
    • Optionalconversion_tracking?: {
          action_sources?: ActionSource[];
          supported_targets?: ("cost_per" | "per_ad_spend" | "maximize_value")[];
          platform_managed?: boolean;
      }

      Conversion event tracking for this product. Presence indicates the product supports optimization_goals with kind: 'event'. Seller-level capabilities (supported event types, UID types, attribution windows) are declared in get_adcp_capabilities.

      • Optionalaction_sources?: ActionSource[]

        Action sources relevant to this product (e.g. a retail media product might have 'in_store' and 'website', while a display product might only have 'website')

      • Optionalsupported_targets?: ("cost_per" | "per_ad_spend" | "maximize_value")[]

        Target kinds available for event goals on this product. Values match target.kind on the optimization goal. cost_per: target cost per conversion event. per_ad_spend: target return on ad spend (requires value_field on event sources). maximize_value: maximize total conversion value without a specific ratio target (requires value_field). Only these target kinds are accepted — goals with unlisted target kinds will be rejected. A goal without a target implicitly maximizes conversion count within budget — no declaration needed for that mode. When omitted, buyers can still set target-less event goals.

      • Optionalplatform_managed?: boolean

        Whether the seller provides its own always-on measurement (e.g. Amazon sales attribution for Amazon advertisers). When true, sync_event_sources response will include seller-managed event sources with managed_by='seller'.

    • Optionalcatalog_match?: {
          matched_gtins?: string[];
          matched_ids?: string[];
          matched_count?: number;
          submitted_count: number;
      }

      When the buyer provides a catalog on get_products, indicates which catalog items are eligible for this product. Only present for products where catalog matching is relevant (e.g., sponsored product listings, job boards, hotel ads).

      • Optionalmatched_gtins?: string[]

        GTINs from the buyer's catalog that are eligible on this product's inventory. Standard GTIN formats (GTIN-8 through GTIN-14). Only present for product-type catalogs with GTIN matching.

      • Optionalmatched_ids?: string[]

        Item IDs from the buyer's catalog that matched this product's inventory. The ID type depends on the catalog type and content_id_type (e.g., SKUs for product catalogs, job_ids for job catalogs, offering_ids for offering catalogs).

      • Optionalmatched_count?: number

        Number of catalog items that matched this product's inventory.

        0

      • submitted_count: number

        Total catalog items evaluated from the buyer's catalog.

        0

    • Optionalbrief_relevance?: string

      Explanation of why this product matches the brief (only included when brief is provided)

    • Optionalexpires_at?: string

      Expiration timestamp. After this time, the product may no longer be available for purchase and create_media_buy may reject packages referencing it.

      date-time

    • Optionalproduct_card?: {
          image?: ImageAsset;
          title?: string;
          description?: string;
          price_label?: string;
          cta_label?: string;
      }

      Optional standard visual card for displaying this product in user interfaces (catalog browsers, dashboards, agent UIs). Distinct from format — product_card describes the UI rendering of the product itself, not the ad creative the product accepts. Typed inline; no format_id indirection. Receivers render the card directly from these fields.

      • Optionalimage?: ImageAsset
      • Optionaltitle?: string

        Card title (typically the product name).

        60

      • Optionaldescription?: string

        Short descriptive blurb shown below the title.

        200

      • Optionalprice_label?: string

        Formatted price or pricing summary (e.g., 'From $5 CPM', 'Auction floor $0.50 CPC'). Free-text — receivers render verbatim.

        30

      • Optionalcta_label?: string

        Call-to-action button label (e.g., 'View details', 'Get proposal').

        25

    • Optionalproduct_card_detailed?: {
          hero_image?: ImageAsset;
          carousel_images?: ImageAsset[];
          title?: string;
          description?: string;
          specifications?: { label: string; value: string }[];
          price_label?: string;
          cta_label?: string;
      }

      Optional detailed card with hero + carousel + structured specifications, for rich product presentation (media-kit-style pages, full product detail views). Distinct from format — describes the UI rendering of the product itself, not the ad creative the product accepts. Typed inline; no format_id indirection.

      • Optionalhero_image?: ImageAsset
      • Optionalcarousel_images?: ImageAsset[]

        Additional images for a swipeable carousel below the hero.

      • Optionaltitle?: string

        Page title (typically the product name).

      • Optionaldescription?: string

        Full descriptive copy. Markdown allowed in client renderers that support it; otherwise treat as plain text.

      • Optionalspecifications?: { label: string; value: string }[]

        Structured key/value specifications (e.g., 'Aspect ratio: 9:16', 'Duration: 30s'). Each item is a labeled fact about the product.

      • Optionalprice_label?: string

        Formatted price or pricing summary.

      • Optionalcta_label?: string

        Call-to-action button label.

    • Optionalcollections?: CollectionSelector[]

      Collections available in this product. Each entry references collections declared in an adagents.json by domain and collection ID. Buyers resolve full collection objects from the referenced adagents.json.

    • Optionalcollection_targeting_allowed?: boolean

      Whether buyers can target a subset of this product's collections. When false (default), the product is a bundle — buyers get all listed collections. When true, buyers can select specific collections in the media buy.

    • Optionalinstallments?: Installment[]

      Specific installments included in this product. Each installment references its parent collection via collection_id when the product spans multiple collections. When absent with collections present, the product covers the collections broadly (run-of-collection).

    • Optionalenforced_policies?: string[]

      Registry policy IDs the seller enforces for this product. Enforcement level comes from the policy registry. Buyers can filter products by required policies.

    • Optionaltrusted_match?: {
          context_match: boolean;
          identity_match?: boolean;
          response_types?: TMPResponseType[];
          dynamic_brands?: boolean;
          providers?: {
              agent_url: string;
              context_match?: boolean;
              identity_match?: boolean;
              countries?: string[];
              uid_types?: UIDType[];
          }[];
      }

      Trusted Match Protocol capabilities for this product. When present, the product supports real-time contextual and/or identity matching via TMP. Buyers use this to determine what response types the publisher can accept and whether brands can be selected dynamically at match time.

      • context_match: boolean

        Whether this product supports Context Match requests. When true, the publisher's TMP router will send context match requests to registered providers for this product's inventory.

      • Optionalidentity_match?: boolean

        Whether this product supports Identity Match requests. When true, the publisher's TMP router will send identity match requests to evaluate user eligibility.

      • Optionalresponse_types?: TMPResponseType[]

        What the publisher can accept back from context match.

      • Optionaldynamic_brands?: boolean

        Whether the buyer can select a brand at match time. When false (default), the brand must be specified on the media buy/package. When true, the buyer's offer can include any brand — the publisher applies approval rules at match time. Enables multi-brand agreements where the holding company or buyer agent selects brand based on context.

      • Optionalproviders?: {
            agent_url: string;
            context_match?: boolean;
            identity_match?: boolean;
            countries?: string[];
            uid_types?: UIDType[];
        }[]

        TMP providers integrated with this product's inventory. Each entry identifies a provider by agent_url (from the registry) and declares what match types it supports for this product. The product-level context_match and identity_match booleans declare what the product supports overall; the per-provider booleans declare which provider handles each match type. Enables buyer discovery: 'find products where a specific provider does context matching.'

    • Optionalmaterial_submission?: { url?: string; email?: string; instructions?: string; ext?: ExtensionObject }

      Instructions for submitting physical creative materials (print, static OOH, cinema). Present only for products requiring physical delivery outside the digital creative assignment flow. Buyer agents MUST validate url and email domains against the seller's known domains (from adagents.json) before submitting materials. Never auto-submit without human confirmation.

      • Optionalurl?: string

        HTTPS URL for uploading or submitting physical creative materials

        ^https://

      • Optionalemail?: string

        Email address for creative material submission

        email

      • Optionalinstructions?: string

        Human-readable instructions for material submission (file naming conventions, shipping address, etc.)

        2000

      • Optionalext?: ExtensionObject
    • Optionalext?: ExtensionObject