Making your inventory available to AI agents

Seller integration guide for AdCP. How publishers, SSPs, and ad platforms expose inventory to AI buyer agents through standardized product discovery and media buy tasks.

AI agents are starting to buy media. When an agency’s AI assistant is evaluating ad inventory across platforms, it needs a way to discover what you sell, understand your pricing and targeting options, and execute a buy — all through a standard interface.

AdCP (Ad Context Protocol) provides that interface. If you’re a publisher, SSP, or ad platform, implementing AdCP makes your inventory accessible to any compliant buyer agent without requiring custom integrations for each one.

Why this matters

Today, every platform requires buyers to learn a proprietary API. That works when humans are doing the buying. But AI agents work across many platforms simultaneously, and they need a shared language for common operations.

Platforms that implement AdCP are discoverable by buyer agents out of the box. Platforms that don’t require each buyer to build a custom integration — which limits the pool of agents that can access your inventory.

What you need to implement

AdCP sell-side integration has three parts:

1. Make your agent discoverable
2. Publish an adagents.json file at your domain root. This file declares your properties and the agents authorized to sell your inventory — similar to how ads.txt works for supply chain transparency.
3. {
     "version": "1.0",
     "properties": [
       {
         "domain": "publisher.example.com",
         "agents": [
           {
             "agent_url": "https://ads.publisher.example.com",
             "relationship": "direct",
             "supported_protocols": ["media_buy", "creative"]
           }
         ]
       }
     ]
   }
   

4. Buyer agents check adagents.json to find authorized sales agents, verify relationships, and discover which protocol domains you support.
5. Expose your inventory
6. Implement get_products to describe what you sell. Each product represents a buyable unit — a display placement, a video slot, a sponsored listing, a newsletter sponsorship. Buyer agents call this with a buying_mode and optional brief:
7. {
     "buying_mode": "brief",
     "brief": "Premium display placements for consumer electronics brand"
   }
   

8. Your response includes structured product objects with pricing, formats, and delivery types:
9. {
     "products": [
       {
         "product_id": "homepage_leaderboard",
         "name": "Homepage leaderboard",
         "channels": ["display"],
         "format_ids": [
           { "agent_url": "https://ads.publisher.example.com", "id": "display_728x90" }
         ],
         "pricing_options": [
           {
             "pricing_option_id": "cpm_standard",
             "pricing_model": "cpm",
             "floor_price": 8.00,
             "currency": "USD"
           }
         ]
       }
     ]
   }
   

10. The richer the product metadata, the better buyer agents can match your inventory to campaign requirements.
11. For content-centric inventory like podcasts, CTV, or live events, products reference shows and can offer exclusivity:
12. {
      "products": [
        {
          "product_id": "signal_noise_sponsorship",
          "name": "Signal & Noise — Category Sponsorship",
          "description": "Category-exclusive sponsorship of the Signal & Noise podcast, including pre-roll and mid-roll host read placements.",
          "collections": [{ "publisher_domain": "crestnetwork.example.com", "collection_ids": ["signal_noise"] }],
          "publisher_properties": ["crestnetwork_podcast"],
          "channels": ["podcast"],
          "placements": [
            { "placement_id": "pre_roll", "name": "Pre-roll (30s)" },
            { "placement_id": "host_read", "name": "Mid-roll host read (60s)" }
          ],
          "delivery_type": "guaranteed",
          "exclusivity": "category",
          "format_ids": [
            { "agent_url": "https://ads.publisher.example.com", "id": "audio_30s" }
          ],
          "pricing_options": [
            {
              "pricing_option_id": "flat_monthly",
              "pricing_model": "flat_rate",
              "fixed_price": 15000,
              "currency": "USD"
            }
          ]
        }
      ]
    }
    

13. See Collections and installments for the full content model and Media products for exclusivity patterns.
14. Accept and fulfill buys
15. Implement create_media_buy to accept campaign instructions from buyer agents. A media buy includes the product, budget, schedule, and any targeting parameters.
16. {
      "account": { "account_id": "acct-56789" },
      "brand": { "brand_id": "nova-electronics" },
      "proposal_id": "prop-homepage-leaderboard",
      "total_budget": { "amount": 10000, "currency": "USD" },
      "start_time": "2026-04-01T00:00:00Z",
      "end_time": "2026-04-30T23:59:59Z"
    }
    

17. Your platform processes the buy according to your normal workflow — whether that’s instant activation, internal review, or an approval queue. AdCP’s asynchronous status system (completed, working, submitted, input-required) lets you model any workflow.

Industry-specific guidance

The core integration steps above apply to all sellers. If you’re an ad network aggregating across multiple platforms, see the ad networks deep dive for product modeling, account chains, catalog forwarding, and adagents.json for networks.

For vertical-specific product modeling, pricing patterns, and measurement:

• AI platforms and AI ad networks: See the Sponsored Intelligence guide for sponsored responses, AI search products, generative creative from catalogs, and SI Chat Protocol handoffs.
• Retail media networks: See the commerce media guide for sponsored product listings, closed-loop attribution, and in-store measurement.

Accounts and sandbox

Production sales agents should implement the accounts protocol. sync_accounts and list_accounts let buyers establish billing relationships, track spend per advertiser, and manage multiple operators buying on behalf of different brands through a single agent.

The account model depends on your platform:

• Walled gardens (social platforms, AI platforms, retail media networks) typically use explicit accounts — set require_operator_auth: true in get_adcp_capabilities so each operator authenticates independently.
• Open platforms (publishers, SSPs) can use implicit accounts — the agent is trusted and declares accounts via sync_accounts.

See Accounts and Agents for full workflows.

Sandbox support is strongly recommended. Declare account.sandbox: true in your capabilities so buyers can provision test accounts and validate the full integration — product discovery, media buy creation, delivery reporting — before committing real spend. Without sandbox, buyers must test against live inventory, which slows adoption and increases onboarding friction. See Sandbox mode for implementation details.

Optional: delivery reporting

Implement get_media_buy_delivery to let buyer agents pull performance data — impressions, clicks, spend, conversions — in a standardized format. This is how agents monitor campaigns across platforms without logging into each dashboard individually.

Product design patterns

Different inventory types use different AdCP features:

Inventory type	Key features
Standard display/video	format_ids, delivery_type: "non_guaranteed", auction pricing
Podcast sponsorship	shows, placements (host read), delivery_type: "guaranteed", flat_rate
CTV series sponsorship	shows, exclusivity, delivery_type: "guaranteed"
Live event	shows (cadence: event), episodes (flexible_end, tentative), exclusivity
Retail media	catalog_types, catalog_match, metric optimization

For content-centric inventory, see Collections and installments. For exclusivity and sponsorship patterns, see Media products.

Governance enforcement

Buyer agents increasingly require governance compliance before committing spend. Implementing governance makes your inventory eligible for brand-safe campaigns, reduces post-campaign disputes, and signals to buyer agents that your platform takes brand suitability seriously. Three governance domains are relevant to sellers.

Property governance via adagents.json

Your adagents.json file is the foundation of property governance. It declares which properties you sell, which agents are authorized to sell them, and which governance agents have data about your inventory. Buyer agents use this to verify supply path authorization and discover property intelligence — if your adagents.json is missing or incomplete, buyer agents cannot verify that you are authorized to sell what you claim.

Declare property_features entries to point buyers toward governance agents that score your properties for quality, sustainability, or brand safety. See the property governance specification for the full schema and the adagents.json tech spec for publisher-side setup.

Content standards enforcement

When a buyer includes a content_standards_ref in a get_products or create_media_buy request, they are asking you to enforce brand suitability rules during delivery. Your responsibilities: fetch the standards from the referenced governance agent, evaluate whether you can enforce them, reject the buy if you cannot, and calibrate your local evaluation model against the governance agent via calibrate_content. After delivery, push content artifacts back to the buyer so they can validate compliance independently.

If you cannot meaningfully enforce a buyer’s content standards, reject the buy rather than accepting it and failing silently. See the content standards implementation guide for the full sales agent workflow.

Execution checks

When a buyer’s account has governance agents configured (via sync_governance), the seller MUST call check_governance with media_buy_id and planned_delivery before confirming a media buy. This is a binding validation — the governance agent verifies the seller’s planned delivery against the buyer’s campaign plan.

// Before confirming create_media_buy
const check = await governanceAgent.checkGovernance({
  plan_id: mediaBuy.plan_id,  // from the create_media_buy request
  caller: "https://seller.example.com",
  governance_context: mediaBuy.governance_context,  // opaque — pass through, do not parse
  media_buy_id: mediaBuy.media_buy_id,
  phase: "purchase",
  planned_delivery: {
    geo: { countries: ["US"] },
    channels: ["olv"],
    start_time: mediaBuy.start_time,
    end_time: mediaBuy.end_time,
    total_budget: mediaBuy.total_budget.amount,
    currency: mediaBuy.total_budget.currency
  }
});

if (check.status === "denied") {
  // Committed checks are always binding — do not confirm the media buy
  return { error: "GOVERNANCE_DENIED", detail: check.explanation };
}

if (check.status === "conditions" && retries < 3) {
  // Conditions restrict what the seller can deliver — e.g., narrower geo,
  // blocked channels, reduced frequency. The seller adjusts their own
  // delivery parameters (not the buyer's budget) and re-calls check_governance.
  // If the seller cannot satisfy the conditions, reject the media buy.
  const adjusted = applyConditions(plannedDelivery, check.conditions);
  if (!adjusted) {
    return { error: "GOVERNANCE_CONDITIONS_UNSATISFIABLE", detail: check.conditions };
  }
  // Re-check with adjusted delivery (governance agents SHOULD deny after 3 re-calls)
  return await checkGovernanceWithRetry(request, adjusted, retries + 1);
}
if (check.status === "conditions") {
  return { error: "GOVERNANCE_CONDITIONS_RETRY_LIMIT", detail: check.conditions };
}

// check.status === "approved" — proceed with confirmation

Execution checks cover three phases of the media buy lifecycle:

Phase	When to call	What’s checked
purchase	Before confirming create_media_buy	Budget, geo, channels, flight dates, policies
modification	Before confirming update_media_buy	Change magnitude, reallocation, new parameters
delivery	Periodically during delivery	Pacing, spend rate, geo drift, channel distribution

Sellers can adopt execution checks incrementally — start with purchase-only (one call per create_media_buy), then add modification and delivery checks. See check_governance for the full specification.

Campaign governance context

When a buyer includes governance_context in the protocol envelope of a create_media_buy request, store it alongside the media buy. This is an opaque value — you don’t interpret it, you just persist and forward it.

Pass governance_context back to the buyer’s governance agent on every lifecycle event for that media buy:

Lifecycle event	How governance_context flows
Create	Received in create_media_buy envelope. Store it. If calling check_governance, include it.
Activate	Include stored governance_context when calling check_governance with the seller’s planned_delivery.
Update	Include on check_governance for modifications. The governance agent uses it to track cumulative changes.
Pause / Resume	Include if calling check_governance. The governance agent updates pacing state.
Cancel / Complete	Include so the governance agent can close out budget tracking and produce final audit.
Delivery webhooks	Include in webhook payloads so the governance agent can correlate delivery data.

The governance agent uses governance_context to reconnect each event to the original plan, campaign, and budget state. Without it, the governance agent has no way to track the media buy across its lifecycle.

If governance_context is not present in the original request, skip governance calls — the buyer is not using campaign governance for this media buy.

Creative governance

Buyer agents may require creative evaluation before delivery — security scanning, content categorization, or quality scoring. As a seller, you participate by submitting creative manifests to governance agents via get_creative_features and honoring the feature requirements the buyer sets (for example, blocking creatives flagged for auto_redirect or credential_harvest). You do not need to implement the evaluation yourself; specialist governance agents handle that.

See the creative governance overview for the feature-based evaluation model and multi-agent collaboration pattern.

For Sponsored Intelligence sellers: generation-time enforcement

Traditional sellers apply governance as a post-delivery filter — classify content, then block what fails. Sponsored Intelligence platforms generate creative at serve time, which means governance rules can be enforced during generation rather than after the fact. When a buyer pushes content standards, apply them as constraints on your generation pipeline so unsuitable content is never produced. This gives brands a fundamentally stronger guarantee: suitability is built into the output, not bolted on as a check afterward. See the Sponsored Intelligence guide for how content standards integrate with catalog-driven creative generation.

How it connects to your existing stack

AdCP sits alongside your existing APIs and dashboards. It doesn’t replace your self-serve platform or your internal campaign management system. It adds a standard interface that AI agents can use.

Your existing system	How AdCP relates
Self-serve dashboard	AdCP serves a different audience (AI agents, not humans)
Management API	AdCP provides a standard subset; your API provides the full feature set
Ad server (GAM, custom)	AdCP sends campaign instructions; your ad server handles delivery
OpenRTB integration	AdCP handles campaign setup; OpenRTB handles impression-level auctions

Getting started

adagents.json builder

Create and validate your adagents.json file using the interactive builder.

Media buy specification

Full reference for sell-side task implementations: products, media buys, and delivery reporting.

Building with AdCP

Implementation guides, SDKs, and integration patterns.

Ask Addie

Ask questions about implementing AdCP for your platform — no code required.

Sponsored Intelligence guide

Product modeling and workflows for AI platforms and ad networks.

Commerce media guide

Product modeling and workflows for retail media networks.