@adcp/sdk API Reference - v14.0.0-beta.6
    Preparing search index...

    Interface CanonicalFormatVASTVideo

    VAST-tag-delivered video creative. Slot: vast_tag (vast asset, URL or inline XML, VAST 2.x-4.x). Tracking model: VAST events inherent to the spec — impression, firstQuartile, midpoint, thirdQuartile, complete, start, pause, resume, mute, unmute, expand, collapse, fullscreen, creativeView, clickTracking, error. VPAID interactivity via vpaid_enabled: true flag. SIMID extensions for interactive video supported as VAST extensions. Orientation is a parameter (vertical / horizontal / square). Distinct from video_hosted (direct file with external tracking).

    interface CanonicalFormatVASTVideo {
        experimental?: boolean;
        deprecated?: boolean;
        v1_translatable?: boolean;
        since_version?: string;
        migration_target_version?: string;
        composition_model?: "deterministic" | "algorithmic";
        provenance_required?: boolean;
        platform_extensions?: PlatformExtensionReference[];
        synthesis_nondeterministic?: boolean;
        slots?: {
            asset_group_id: string;
            asset_type:
                | "object"
                | "image"
                | "video"
                | "audio"
                | "text"
                | "markdown"
                | "html"
                | "css"
                | "javascript"
                | "zip"
                | "vast"
                | "daast"
                | "url"
                | "webhook"
                | "brief"
                | "catalog"
                | "published_post"
                | "pixel_tracker"
                | "vast_tracker"
                | "daast_tracker"
                | "card";
            required?: boolean;
            min?: number;
            max?: number;
            max_chars?: number;
            max_size_kb?: number;
            pixel_ratios?: number[];
            required_pixel_ratios?: number[];
            logo_slots?: LogoSlot[];
            required_logo_slots?: LogoSlot[];
            description?: string;
            consumed_for_production?: boolean;
        }[];
        required_connections?: {
            provider?: string;
            connection_type: | "advertiser_account"
            | "publisher_identity"
            | "post_authorization";
            required_for?: string[];
            scope?: "unknown"
            | "account"
            | "identity"
            | "post";
            status?:
                | "unknown"
                | "pending"
                | "expired"
                | "revoked"
                | "not_required"
                | "connected"
                | "missing";
            connection_id?: string;
            resource_ref?: {
                platform_account_id?: string;
                identity_id?: string;
                handle?: string;
                profile_url?: string;
                post_id?: string;
                post_url?: string;
            };
            authorization_url?: string;
            authorization_instructions?: string;
            expires_at?: string;
        }[];
        reference_mutability?: | "immutable_snapshot"
        | "mutable_requires_reapproval"
        | "mutable_auto_recheck";
        production_window_business_days?: number;
        orientation?: "vertical"
        | "horizontal"
        | "square";
        aspect_ratio?: string;
        vast_version?: VASTVersion;
        vpaid_enabled?: boolean;
        vpaid_version?: "1.0" | "2.0";
        simid_supported?: boolean;
        duration_ms_range?: number[];
        duration_ms_exact?: number;
        min_width?: number;
        max_width?: number;
        min_height?: number;
        max_height?: number;
        linear_required?: boolean;
        skippable_after_ms?: number;
        max_wrapper_depth?: number;
        ssl_required?: boolean;
    }
    Index

    Properties

    experimental?: boolean

    When true, this canonical or seller narrowing may not work as declared. Adopters SHOULD preflight it with validate_input or in a sandbox and SHOULD NOT route production budget without testing; experimental status never makes the deprecated v1 path preferable. Drivers include unsettled spec shape, an adopter runtime gap, and custom shapes awaiting promotion. This replaces the earlier status plus runtime_status axes. Sellers SHOULD set experimental whenever a canonical or declaration is not production-ready.

    deprecated?: boolean

    When true, this canonical (or a seller's specific narrowing of it) is going away. Existing adopters are supported through the deprecation cycle; new adoption is discouraged. Pair with migration_target_version to indicate when the canonical is expected to be removed. Distinct from experimental: an experimental canonical may stabilize and stop being experimental; a deprecated canonical is on a sunset path.

    v1_translatable?: boolean

    Whether this canonical has any v1 named-format equivalent. true (default) — the canonical is structurally expressible as one or more v1 named formats (IAB display sizes, VAST tags, DAAST tags, etc.); v1→v2 projection via v1-canonical-mapping.json is meaningful. false — the canonical is inherently new in v2 and has no v1 form; v1's list_creative_formats couldn't express it because the underlying concept (algorithmic surface composition, AI-surface mentions, retail-media catalog placements, multi-card carousels) didn't exist as a v1 named-format archetype.

    Lets SDKs distinguish two failure modes that today look identical: (a) the registry hasn't covered this canonical yet (correctable — seller adds explicit canonical field or files a registry entry) vs (b) no v1 path is possible (informational — buyer needs v2-aware consumption, or seller declares canonical_formats_only: true on the product declaration). SDKs encountering v1_translatable: false on a canonical SHOULD NOT emit FORMAT_PROJECTION_FAILED (which signals registry-coverage gap) — instead surface the inherent v1-unreachability as a different diagnostic or skip silently. The 4 inherently-v2 canonicals at 3.1 GA: image_carousel, sponsored_placement, responsive_creative, agent_placement.

    since_version?: string

    AdCP MAJOR.MINOR version that introduced this canonical (e.g., '3.1', '3.2'). Lets adopters reason about minimum protocol version requirements when consuming a format declaration. Patch precision is intentionally rejected — canonicals are introduced at minor-version boundaries.

    migration_target_version?: string

    AdCP MAJOR.MINOR version by which the working group expects this canonical to stabilize, surface a breaking revision, or (when deprecated: true) be removed. Patch precision is intentionally rejected — canonicals shift at minor-version boundaries. Absence signals 'no specific target' (omit the field rather than use a placeholder like 'unknown').

    composition_model?: "deterministic" | "algorithmic"

    Whether the surface composes deterministically (buyer can predict per-slot rendering — sponsored_placement, image, video) or algorithmically (surface chooses combinations or phrasing — responsive_creative, agent_placement).

    provenance_required?: boolean

    When true, the product rejects unsigned synthesized assets. Builders calling build_creative MUST attach a C2PA-compatible provenance manifest attributing synthesis to the creative agent.

    platform_extensions?: PlatformExtensionReference[]

    Platform-specific extensions narrowing the canonical (pixel ID shapes, conversion event taxonomies, platform-specific CTAs/destinations). Each extension is a URI+digest reference resolved against the bundled extensions map in get_products responses or fetched directly.

    Collision precedence (normative). When two or more platform_extensions[] entries on the same declaration extend the same target (e.g., both extend tracking) with overlapping field names, array order is authoritative — later entries override earlier ones on a per-field basis (last-in-array-wins). SDKs MUST surface the overlap via the errors[] array on the get_products response with a structured code (FORMAT_DECLARATION_DIVERGENT is appropriate when the overlap appears across dual-emitted shapes; a producer-self-emitted overlap on a single declaration SHOULD use the same code with error.details: { collision_kind: "platform_extension_field", target, overlapping_fields, winning_extension_uri }). Producers SHOULD avoid the collision by emitting one extension per target or by partitioning fields across extensions; the deterministic precedence is for last-resort consistency across SDK implementations, not a sanctioned merging strategy.

    synthesis_nondeterministic?: boolean

    When true, the format's production pipeline is genuinely nondeterministic — the platform cannot guarantee that synthesis from a given input set produces in-spec output. Veo / Sora / Runway-class generative video, and other AI-synthesis flows where output dimensions, duration, or quality vary per run. Implies a different validation contract: predictive validate_input is impossible; the platform's own post-synthesis QA loop applies; if the QA loop exhausts without producing a valid artifact, build_creative returns task_failed with a synthesis_failed reason. Distinct from composition_model (which describes how the surface composes per-slot rendering, not whether synthesis is deterministic). When false or absent, the format's production is predictable enough that validate_input can predict output properties from input properties.

    Compatibility with asset_source / item_production_model: synthesis_nondeterministic: true MAY pair with any of seller_pre_rendered_from_brief, seller_human_designed, or agent_synthesized (the QA loop is concept-level, not source-specific — 'seller renders from brief but each retry differs' is just as nondeterministic as Veo). It MUST NOT pair with buyer_uploaded (the buyer ships pre-rendered bytes; there's no synthesis step to be nondeterministic about). It MUST NOT pair with publisher_host_recorded (the publisher's host produces a deterministic-from-script output even if the human voice varies). When synthesis_nondeterministic: true is set with an incompatible source, validators SHOULD reject with a structured error.

    slots?: {
        asset_group_id: string;
        asset_type:
            | "object"
            | "image"
            | "video"
            | "audio"
            | "text"
            | "markdown"
            | "html"
            | "css"
            | "javascript"
            | "zip"
            | "vast"
            | "daast"
            | "url"
            | "webhook"
            | "brief"
            | "catalog"
            | "published_post"
            | "pixel_tracker"
            | "vast_tracker"
            | "daast_tracker"
            | "card";
        required?: boolean;
        min?: number;
        max?: number;
        max_chars?: number;
        max_size_kb?: number;
        pixel_ratios?: number[];
        required_pixel_ratios?: number[];
        logo_slots?: LogoSlot[];
        required_logo_slots?: LogoSlot[];
        description?: string;
        consumed_for_production?: boolean;
    }[]

    Default slots for video_vast canonical. Buyer ships a VAST tag (URL or inline XML, VAST 2.x-4.x) plus an optional clickthrough URL (which falls back to the VAST ClickThrough element when omitted). Tracking events are inherent to VAST and don't require explicit slots.

    Type Declaration

    • asset_group_id: string

      Canonical asset_group_id from /schemas/core/asset-group-vocabulary.json. Non-canonical IDs are valid but trigger soft warnings.

    • asset_type:
          | "object"
          | "image"
          | "video"
          | "audio"
          | "text"
          | "markdown"
          | "html"
          | "css"
          | "javascript"
          | "zip"
          | "vast"
          | "daast"
          | "url"
          | "webhook"
          | "brief"
          | "catalog"
          | "published_post"
          | "pixel_tracker"
          | "vast_tracker"
          | "daast_tracker"
          | "card"

      Discriminator selecting the asset schema this slot accepts. SDK codegen uses this to type the slot value. published_post is an existing-post reference asset, not uploaded media bytes and not a catalog row. card is the multi-card carousel element type (see card-asset.json). pixel_tracker / vast_tracker / daast_tracker are the renderer-fired measurement-tracker primitives — see /schemas/core/assets/pixel-tracker-asset.json and the VAST / DAAST tracker schemas. object is a last-resort fallback for structured non-asset inputs that don't fit any primitive asset_type — prefer specific types whenever possible.

    • Optionalrequired?: boolean

      Whether this slot is required for a valid manifest.

    • Optionalmin?: number

      Minimum count for repeatable / pool slots.

    • Optionalmax?: number

      Maximum count for repeatable / pool slots.

    • Optionalmax_chars?: number

      Per-slot character limit. Valid only when asset_type is text, markdown, or brief. Mutually exclusive with max_size_kb (which applies to binary asset types). Schema enforces via if/then so a producer can't set both on the same slot.

    • Optionalmax_size_kb?: number

      Per-slot file size limit in kilobytes. Valid only when asset_type is image, video, audio, or zip. Mutually exclusive with max_chars (which applies to text asset types). Schema enforces via if/then so a producer can't set both on the same slot.

    • Optionalpixel_ratios?: number[]

      Accepted intrinsic-pixel densities for this image-bearing slot. Valid when asset_type is image, and on a card slot where it constrains each card's image media (video media is unaffected). This makes density available to every canonical carrying image assets (native, carousel, responsive, companion images, and image itself), not only format_kind: image. When the image canonical also declares top-level params.pixel_ratios, the effective set is the intersection; an empty intersection is invalid. One matching asset satisfies the slot unless required_pixel_ratios requires rendition coverage.

    • Optionalrequired_pixel_ratios?: number[]

      Required density coverage for an image rendition set. Valid only when asset_type is image and pixel_ratios is also declared. Every value MUST appear in the effective accepted set after intersecting any top-level image params.pixel_ratios, and the manifest slot value MUST be an array containing exactly one matching image rendition for each required ratio. Other accepted ratios remain optional. For example, pixel_ratios: [1, 1.5, 2] with required_pixel_ratios: [1, 2] requires the 1x and 2x renditions while making 1.5x optional. SDKs enforce intersection, subset, coverage, and duplicate-ratio rules because JSON Schema draft-07 cannot express them generically.

    • Optionallogo_slots?: LogoSlot[]

      When asset_group_id is logo, renderer-facing brand.json logo slots acceptable for this format slot. Producers selecting from brand.json SHOULD prefer logos[] entries whose slots[] intersects this list, then apply visual_guidelines.logo_usage_rules[].

    • Optionalrequired_logo_slots?: LogoSlot[]

      Subset of logo_slots for which this format expects explicit logo coverage. A manifest or brand-derived logo pool SHOULD include at least one usable logo for each required slot; if coverage is missing, builders SHOULD surface a validation warning or approval mapping instead of guessing from prose.

    • Optionaldescription?: string

      Human-readable description of what the slot expects from the buyer.

    • Optionalconsumed_for_production?: boolean

      Dispatch hint for build_creative and v1↔v2 wire translators: when true, the slot's value is consumed as INPUT to a production step (host-read script, brief copy fed to generative synthesis, catalog feed driving per-SKU rendering) and is not rendered verbatim. When false (default), the slot's value is rendered verbatim on the placement (image bytes, video file, display tag).

      Motivates the v1↔v2 dispatch table: pre-v2 buyers shipped production-consumed inputs separately in a inputs map on the build_creative request; v2 collapses inputs and rendered assets into a single assets map keyed by asset_group_id. SDK translators between v1 and v2 use this flag per canonical to know which assets in the v2 manifest map back to v1 inputs vs v1 assets. Without the per-slot flag the dispatch table lives in adopter code and every SDK gets it slightly different.

      Producers SHOULD set this explicitly on slots whose consumption pattern isn't obvious (host-read scripts on audio_hosted, briefs on generative video_hosted, catalog feeds on sponsored_placement). For canonicals where every slot is render-verbatim (image, display_tag, video_vast), the default false is sufficient and the flag MAY be omitted.

    required_connections?: {
        provider?: string;
        connection_type:
            | "advertiser_account"
            | "publisher_identity"
            | "post_authorization";
        required_for?: string[];
        scope?: "unknown"
        | "account"
        | "identity"
        | "post";
        status?:
            | "unknown"
            | "pending"
            | "expired"
            | "revoked"
            | "not_required"
            | "connected"
            | "missing";
        connection_id?: string;
        resource_ref?: {
            platform_account_id?: string;
            identity_id?: string;
            handle?: string;
            profile_url?: string;
            post_id?: string;
            post_url?: string;
        };
        authorization_url?: string;
        authorization_instructions?: string;
        expires_at?: string;
    }[]

    Downstream platform connections or grants required to use this format declaration. These are in addition to the single AdCP caller credential. Use this when a platform product requires multiple downstream grants, such as an advertiser account connection plus a publisher identity or post authorization for published-post references.

    Type Declaration

    • Optionalprovider?: string

      Stable provider or platform namespace, preferably lowercase. Examples: social.example, shortvideo.example, or a seller-defined namespace. Omit only when the requirement is provider-agnostic, or when an authorization_url fully routes the human to the correct provider-specific connection flow.

    • connection_type: "advertiser_account" | "publisher_identity" | "post_authorization"

      Kind of downstream connection required. advertiser_account is the platform account used to buy/manage ads. publisher_identity is the creator, page, channel, organization, or profile that owns source posts. post_authorization is a post-scoped grant when the platform authorizes individual posts instead of, or in addition to, the owning identity.

    • Optionalrequired_for?: string[]

      Concrete AdCP protocol operation names that require this downstream connection. Sellers SHOULD include this in product declarations when the requirement is known ahead of time, and in AUTHORIZATION_REQUIRED details when it explains the failed operation. Prefer specific operation names such as list_creatives, sync_creatives, create_media_buy, get_media_buy_delivery, or get_creative_delivery over broad category labels such as reporting.

    • Optionalscope?: "unknown" | "account" | "identity" | "post"

      Granularity of the downstream grant.

    • Optionalstatus?:
          | "unknown"
          | "pending"
          | "expired"
          | "revoked"
          | "not_required"
          | "connected"
          | "missing"

      Current seller-observed state for this downstream connection when known. Product declarations MAY omit status or use unknown; AUTHORIZATION_REQUIRED details SHOULD use missing, expired, or revoked for the connection that blocked the call.

    • Optionalconnection_id?: string

      Seller-defined identifier for an already-created downstream connection. Omit when no connection exists yet or when exposing it would leak platform/account state.

    • Optionalresource_ref?: {
          platform_account_id?: string;
          identity_id?: string;
          handle?: string;
          profile_url?: string;
          post_id?: string;
          post_url?: string;
      }

      Optional opaque provider-native resource hint, such as a platform account id, profile URL, handle, channel id, post id, or post URL. This is a hint for routing authorization, not proof that authorization exists.

      • Optionalplatform_account_id?: string

        Provider-native advertiser or business account id, when safe to disclose.

      • Optionalidentity_id?: string

        Provider-native creator, page, channel, organization, or profile id, when safe to disclose.

      • Optionalhandle?: string

        Provider-native public handle for the owning identity, when available.

      • Optionalprofile_url?: string

        Public URL for the owning identity, when available.

      • Optionalpost_id?: string

        Provider-native post id, when the grant is post-scoped or the failed request referenced a specific post.

      • Optionalpost_url?: string

        Public URL for the referenced post, when available.

    • Optionalauthorization_url?: string

      Seller-hosted or provider-hosted URL where a human can complete or restore this downstream connection.

    • Optionalauthorization_instructions?: string

      Human-readable instructions for completing or restoring this downstream connection.

    • Optionalexpires_at?: string

      Expiration time for the downstream grant, when known.

    reference_mutability?:
        | "immutable_snapshot"
        | "mutable_requires_reapproval"
        | "mutable_auto_recheck"

    Policy for formats whose slots accept a published_post reference. immutable_snapshot: seller snapshots the referenced post at approval and later source changes do not change the served creative. mutable_requires_reapproval: the source post may change and material changes require review before continued serving. mutable_auto_recheck: the source post may change and the seller continuously or periodically rechecks authorization/policy without requiring buyer resubmission. Omit when the format has no published_post slot.

    production_window_business_days?: number

    Typical production turnaround in business days when the format requires seller-side production (e.g., host-recording from a buyer-supplied script). 0 for synchronous (e.g., generative AI); >0 for human-produced (e.g., podcast host-read). Absent when no production is required (buyer uploads complete creative).

    orientation?: "vertical" | "horizontal" | "square"
    aspect_ratio?: string

    ^[0-9]+(.[0-9]+)?:[0-9]+(.[0-9]+)?$

    vast_version?: VASTVersion
    vpaid_enabled?: boolean

    Whether VPAID interactivity is supported. When true, the VAST tag may carry VPAID JS/Flash payloads.

    vpaid_version?: "1.0" | "2.0"
    simid_supported?: boolean

    Whether IAB SIMID interactive video extensions are supported.

    duration_ms_range?: number[]

    [min, max] duration in milliseconds. Precedence: duration_ms_exact takes precedence when both ship. SDKs SHOULD lint a warning when both fields ship.

    duration_ms_exact?: number

    When set, duration must equal exactly this value. Takes precedence over duration_ms_range when both ship.

    1

    min_width?: number

    1

    max_width?: number

    1

    min_height?: number

    1

    max_height?: number

    1

    linear_required?: boolean

    Whether the VAST creative must be linear (non-skippable in-stream).

    skippable_after_ms?: number

    When skippable, the buyer-side skip threshold in milliseconds (e.g., 5000 for 5-second skippable pre-roll).

    0

    max_wrapper_depth?: number

    Maximum VAST wrapper redirect depth permitted.

    0

    ssl_required?: boolean