> ## Documentation Index > Fetch the complete documentation index at: https://agenticadvertisingorg-snap-format-preview-links.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Creative Manifests > Creative manifests in AdCP are reusable presets that supply concrete asset values to satisfy format requirements for programmatic ad delivery. Creative manifests define a creative preset: a reusable configuration of brand content that can be instantiated in a specific creative format. Three columns showing how a format defines required slots, a manifest fills them with concrete values, and the result is a rendered creative A manifest does not define structure, layout, or rendering behavior. Instead, it supplies concrete asset values that satisfy the requirements defined by a creative format. When combined with a format definition, a manifest produces a renderable creative instance. For an overview of how formats, manifests, and creative agents work together, see the [Creative Protocol Overview](/docs/creative). ## Manifest Structure ### Basic Structure ```typescript theme={null} { format_id: { // Format this manifest is for agent_url: string; // Creative agent URL id: string; // Format identifier }; assets: { [asset_id: string]: { // Keyed by asset_id from format's assets // Asset type is determined by format specification, not declared here // Type-specific fields depend on asset_type defined in format's assets // Image: url, width, height, format, alt_text // Video: url, width, height, duration_ms, format, bitrate_kbps // Audio: url, duration_ms, format, bitrate_kbps // Text: content, language // Markdown: content, flavor // URL: url, description // HTML: content or url, version // CSS: content, media // JavaScript: content, module_type // VAST: url or content, vast_version, vpaid_enabled, duration_ms, tracking_events // DAAST: url or content, daast_version, duration_ms, tracking_events, companion_ads // Webhook: url, method, timeout_ms, response_type, security, supported_macros, required_macros // Brief: name, objective, tone, audience, messaging, compliance // Catalog: type, catalog_id, items, selectors } }; } ``` ### Asset IDs Each asset in a manifest is keyed by its `asset_id`, which must match an `asset_id` defined in the format's `assets` array. The asset ID serves as the technical identifier for referencing the asset requirement in the format specification. **How Asset IDs Work**: When a format defines required assets: ```json theme={null} { "assets": [ { "asset_id": "banner_image", "asset_type": "image", "required": true }, { "asset_id": "clickthrough_url", "asset_type": "url", "required": true } ] } ``` Your manifest **must use those exact asset IDs** as keys: ```json theme={null} { "assets": { "banner_image": { // ← Matches asset_id from format "url": "https://cdn.example.com/banner.jpg", "width": 300, "height": 250 }, "clickthrough_url": { // ← Matches asset_id from format "url": "https://example.com/landing" } } } ``` **Common Asset IDs** (vary by format): * `banner_image`, `hero_image`: Primary visual assets * `logo`: Brand logo * `headline`, `description`: Text content * `cta_text`: Call-to-action button text * `video_file`: Video content * `vast_tag`: VAST XML for video delivery * `clickthrough_url`: Landing page URL Always check the specific format's `assets` to see which asset IDs are required. ### Complete Example Here's a complete creative manifest showing the current structure without redundant fields: ```json theme={null} { "$schema": "/schemas/core/creative-manifest.json", "format_id": { "agent_url": "https://creative.adcontextprotocol.org", "id": "display_300x250" }, "assets": { "banner_image": { "asset_type": "image", "url": "https://cdn.example.com/banner.jpg", "width": 300, "height": 250 }, "headline": { "asset_type": "text", "content": "Nutrition Dogs Love" }, "description": { "asset_type": "text", "content": "Made with real chicken and wholesome grains" }, "clickthrough_url": { "asset_type": "url", "url": "https://acmecorp.example.com/products/premium-dog-food?campaign={MEDIA_BUY_ID}", "description": "Product landing page" } } } ``` **Note**: Each asset carries an `asset_type` discriminator (`image`, `text`, `url`, etc. — see [asset types](/docs/creative/asset-types)). This lets validators select the matching asset schema and report errors against only the chosen branch instead of all 14. The format specification also declares the expected `asset_type` for each `asset_id`; manifest and format should agree. ## Types of Creative Manifests Creative manifests can be static, dynamic, or hybrid - reflecting the three creative agent modalities above. ### Static Manifests Static manifests contain all assets ready for immediate rendering. These are produced by creative agents in **Static Asset Delivery** or **Prompt to Static Rendering** modes. ```json theme={null} { "$schema": "/schemas/core/creative-manifest.json", "format_id": { "agent_url": "https://creative.adcontextprotocol.org", "id": "native_responsive" }, "assets": { "hero_image": { "asset_type": "image", "url": "https://cdn.example.com/hero.jpg", "width": 1200, "height": 627, "alt_text": "Product image" }, "logo": { "asset_type": "image", "url": "https://cdn.example.com/logo.png", "width": 100, "height": 100 }, "headline": { "asset_type": "text", "content": "Premium Quality You Can Trust" }, "description": { "asset_type": "text", "content": "Discover why veterinarians recommend our formula" }, "cta_text": { "asset_type": "text", "content": "Learn More" } } } ``` **Use Cases**: * Traditional display advertising * Pre-rendered video ads * Static native ads * Fixed creative campaigns ### Dynamic Manifests Dynamic manifests include endpoints or code for real-time generation. These are produced by creative agents in **Prompt to Dynamic Rendering** mode (DCO/Generative). ```json theme={null} { "$schema": "/schemas/core/creative-manifest.json", "format_id": { "agent_url": "https://creative.adcontextprotocol.org", "id": "display_dynamic_300x250" }, "assets": { "dynamic_content": { "asset_type": "webhook", "url": "https://creative-agent.example.com/render/campaign-123", "method": "POST", "timeout_ms": 500, "supported_macros": ["WEATHER", "TIME", "DEVICE_TYPE", "COUNTRY"], "response_type": "html", "security": { "method": "hmac_sha256", "hmac_header": "X-Signature" } }, "fallback_image": { "asset_type": "image", "url": "https://cdn.example.com/fallback-300x250.jpg", "width": 300, "height": 250 } } } ``` **Use Cases**: * Weather-based creative * Time-of-day personalization * Product availability messaging * Real-time inventory updates **Note**: For client-side dynamic rendering, use `html` or `javascript` asset types with embedded tags instead of webhooks. **Dynamic manifests can mix asset types** - some assets may be static (images, videos) while others are dynamic (webhooks, tags with macros). For example, a video VAST tag with a static hero video but a personalized end card webhook. ### DOOH Manifests with Impression Tracking Digital Out-of-Home (DOOH) creatives use impression tracking just like other formats, but with venue-specific macros instead of device identifiers. ```json test=false theme={null} { "format_id": { "agent_url": "https://creative.adcontextprotocol.org", "id": "dooh_billboard_1920x1080" }, "assets": { "billboard_image": { "url": "https://cdn.example.com/billboard-1920x1080.jpg", "width": 1920, "height": 1080 }, "impression_tracker": { "url": "https://tracking.example.com/imp?screen={SCREEN_ID}&venue={VENUE_TYPE}&ts={PLAY_TIMESTAMP}&lat={VENUE_LAT}&lon={VENUE_LONG}", "url_type": "tracker_pixel" } } } ``` **DOOH-Specific Macros** (see [Universal Macros](/docs/creative/universal-macros) for complete list): * `{SCREEN_ID}` - Unique identifier for the physical screen * `{VENUE_TYPE}` - Venue category (airport, mall, transit, highway, retail) * `{VENUE_LAT}` / `{VENUE_LONG}` - Physical location coordinates * `{PLAY_TIMESTAMP}` - When creative displayed (Unix timestamp) * `{DWELL_TIME}` - Average viewer dwell time at this location The mechanics are identical to digital impression tracking - a URL fires when the ad displays. The difference is DOOH uses fixed venue context instead of dynamic device identifiers. ## Working with Manifests ### Creating Manifests Manifests are JSON structures that can be created in two ways: **1. Manual Assembly** Construct manifests directly by pairing format requirements with your assets: ```json theme={null} { "$schema": "/schemas/core/creative-manifest.json", "format_id": { "agent_url": "https://creative.adcontextprotocol.org", "id": "native_responsive" }, "assets": { "hero_image": { "asset_type": "image", "url": "https://cdn.example.com/salmon-hero.jpg", "width": 1200, "height": 627 }, "headline": { "asset_type": "text", "content": "New Premium Salmon Formula" } } } ``` **2. AI-Generated (Optional)** Use `build_creative` on any agent implementing the Creative Protocol to generate manifests from natural language briefs. See [Generative Creative](/docs/creative/generative-creative) for details. ### Validating Manifests Before using a manifest, validate it against format requirements: 1. **Format Compatibility**: Ensure `format_id` matches intended format 2. **Required Assets**: All required `asset_id` values from the format are present as keys in the manifest's `assets` object 3. **Asset Key Matching**: Each key in the manifest's `assets` object MUST match an `asset_id` from the format's `assets` array 4. **Asset Specifications**: Each asset meets format requirements (dimensions, file size, duration, etc.) 5. **Macro Support**: Dynamic manifests properly handle required macros **What happens with invalid asset keys?** * **Missing required asset\_id**: Creative agents MUST reject the manifest with an error listing which required assets are missing * **Unknown asset\_id**: Creative agents MUST reject manifests containing asset keys that don't match any `asset_id` in the format. This catches typos and incompatible formats immediately. * **Wrong asset\_type**: If an asset doesn't match the type requirement for that `asset_id` in the format specification, reject with a clear type mismatch error Creative agents that implement `build_creative` handle validation automatically. For manually constructed manifests, validate against the format specification returned by `list_creative_formats`. **Format-Aware Validation**: Creative manifest validation MUST be performed in the context of the format specification. The format defines what type each `asset_id` should be, eliminating any validation ambiguity. Asset type information is NOT included in the manifest itself - it's determined by looking up the `asset_id` in the format's `assets` array. #### Validation Flow When a creative agent receives a manifest for validation: 1. **Extract format\_id** from the manifest 2. **Fetch format specification** from the format registry (local or remote based on `agent_url`) 3. **For each asset key in `manifest.assets`:** * Look up the `asset_id` in `format.assets` * If not found → **reject** with error "Unknown asset\_id 'banner\_imag' not defined in format" * If found → determine the expected `asset_type` from the format requirement * Fetch the asset type schema (e.g., `/schemas/v3/core/assets/image-asset.json`) * Validate the asset payload against that schema * Validate the asset meets any additional constraints in the format's `requirements` field 4. **Check all required assets are present** (where `required: true` in format spec) 5. **Validate type-specific constraints** (dimensions, file size, duration, etc.) The format specification is the single source of truth for what type each `asset_id` should be and what constraints apply. **Validation is runtime, not schema-time**: The JSON schema for creative manifests uses a flexible pattern (`^[a-z0-9_]+$`) for asset keys because the valid keys depend on which format you're using. Validation against the specific format's `assets` happens when you submit the manifest to a creative agent. ### Previewing Manifests Use the `preview_creative` task to see how a manifest will render: ```json theme={null} { "creative_manifest": { "format_id": { "agent_url": "https://creative.adcontextprotocol.org", "id": "native_responsive" }, "assets": { "hero_image": { "url": "https://cdn.example.com/hero.jpg", "width": 1200, "height": 627 }, // ... other assets } }, "macro_values": { "CLICK_URL": "https://example.com/landing", "CACHE_BUSTER": "12345" } } ``` The creative agent returns preview URLs and renderings. ### Submitting Manifests Manifests are submitted to the creative library using `sync_creatives`, then referenced by ID in media buys: ```json theme={null} { "task": "sync_creatives", "parameters": { "creatives": [ { "creative_id": "native-salmon-v1", "name": "Salmon Special Native Ad", "format_id": { "agent_url": "https://creative.adcontextprotocol.org", "id": "native_responsive" }, "manifest": { "format_id": { "agent_url": "https://creative.adcontextprotocol.org", "id": "native_responsive" }, "assets": { "product_catalog": { "catalog_id": "salmon-products", "type": "product" }, "headline": { "content": "Fresh Pacific Salmon - 20% Off Today" }, "main_image": { "url": "https://cdn.example.com/salmon.jpg", "width": 1200, "height": 628 } } } } ] } } ``` Then reference in media buys by `creative_id`. Each manifest is for a single format. ## Macro Substitution in Manifests Manifests support macro placeholders for dynamic values. AdCP uses universal macros that work consistently across all publishers. See [Universal Macros](/docs/creative/universal-macros) for complete documentation on available macros, macro substitution process, and format-specific macro support. ## Best Practices ### For Creative Agents 1. **Complete Manifests**: Include all required assets for the format 2. **Validate Assets**: Ensure assets meet format specifications 3. **Provide Fallbacks**: Include fallback assets for dynamic creatives 4. **Document Macros**: Clearly specify which macros are used 5. **Version Assets**: Use versioned URLs for asset management ### For Publishers 1. **Validate on Receipt**: Check manifests against format requirements 2. **Cache Assets**: Pre-fetch and cache hosted assets 3. **Handle Failures**: Implement fallback rendering for dynamic manifests 4. **Support Macros**: Implement full Universal Macro support 5. **Provide Templates**: Offer rendering templates for custom formats ### For Buyers 1. **Validate Manifests**: Ensure manifests match format requirements (manually or via `build_creative`) 2. **Preview First**: Always preview manifests before submission 3. **Test Macros**: Verify macro substitution works as expected 4. **Optimize Assets**: Ensure assets are properly sized and compressed 5. **Organize Libraries**: Use creative libraries for asset management ## Advanced Topics ### Catalogs Manifests for catalog-driven formats (product carousels, dynamic product ads) include their catalogs as assets within the `assets` map. See [Catalogs in Creatives](/docs/creative/catalogs#catalogs-in-creatives) for the workflow. ### Repeatable Asset Groups For carousel, slideshow, and multi-asset formats, see the [Carousel & Multi-Asset Formats](/docs/creative/channels/carousels) guide for complete documentation on repeatable asset groups. ## Schema Reference * [Creative Manifest Schema](https://adcontextprotocol.org/schemas/v3/core/creative-manifest.json) * [Preview Creative Request](https://adcontextprotocol.org/schemas/v3/creative/preview-creative-request.json) * [Preview Creative Response](https://adcontextprotocol.org/schemas/v3/creative/preview-creative-response.json) ## Related Documentation * [Creative Formats](/docs/creative/formats) - Understanding format specifications and discovery * [Channel Guides](/docs/creative/channels/video) - Format examples across video, display, audio, DOOH, and carousels * [build\_creative Task](/docs/creative/task-reference/build_creative) * [preview\_creative Task](/docs/creative/task-reference/preview_creative)