get_adcp_capabilities

Discover a seller’s protocol support and capabilities across all AdCP protocols. This is the first call a buyer should make to understand what a seller supports. Response Time: ~2 seconds (configuration lookup) Purpose:

AdCP discovery - Does this agent support AdCP? Which versions?
Protocol support - Which domain protocols (media_buy, signals, governance, sponsored_intelligence, creative)?
Detailed capabilities - Features, AXE integrations, geo targeting, portfolio

Request Schema: /schemas/v1/protocol/get-adcp-capabilities-request.json Response Schema: /schemas/v1/protocol/get-adcp-capabilities-response.json

Tool-Based Discovery

AdCP uses native MCP/A2A tool discovery. The presence of get_adcp_capabilities in an agent’s tool list indicates AdCP support.

Discovery Flow:
Browse agent's tool list (MCP) or skills (A2A)
See 'get_adcp_capabilities' tool → Agent supports AdCP
Call get_adcp_capabilities → Get version, protocols, features, capabilities
Proceed based on returned capabilities

This approach:

Uses standard MCP/A2A mechanisms (no custom extensions)
Always returns current capabilities (not stale metadata)
Single source of truth for all capability information

:::note The agent card extension (adcp-extension.json) has been removed in v3. Use tool-based discovery instead. :::

Request Parameters

Field	Type	Description
`protocols`	string[]	Optional. Filter to specific protocols (`media_buy`, `signals`, `governance`, `sponsored_intelligence`, `creative`). If omitted, returns all supported protocols.

Response Structure

adcp

Core AdCP protocol information:

Field	Type	Description
`major_versions`	integer[]	Required. AdCP major versions supported (e.g., `[1]`)

supported_protocols

Array of domain protocols this seller supports:

{
  "supported_protocols": ["media_buy"]
}

media_buy

Media-buy protocol capabilities. Only present if media_buy is in supported_protocols.

features

Optional media-buy features. If declared true, seller MUST honor requests using that feature.

Feature	Description
`inline_creative_management`	Accepts creatives inline in `create_media_buy` requests
`property_list_filtering`	Honors `property_list` parameter in `get_products`
`content_standards`	Full support for content standards configuration

execution

Technical execution capabilities:

Field	Type	Description
`axe_integrations`	string[]	Agentic ad exchange (AXE) URLs this seller can execute through
`creative_specs`	object	Creative specification support (VAST versions, MRAID, etc.)
`targeting`	object	Targeting capabilities (geo granularity)

creative_specs

Field	Type	Description
`vast_versions`	string[]	VAST versions supported (e.g., `["4.0", "4.1", "4.2"]`)
`mraid_versions`	string[]	MRAID versions supported
`vpaid`	boolean	VPAID support
`simid`	boolean	SIMID support

targeting

Field	Type	Description
`geo_countries`	boolean	Country-level targeting using ISO 3166-1 alpha-2 codes
`geo_regions`	boolean	Region/state-level targeting using ISO 3166-2 codes (e.g., `US-NY`, `GB-SCT`)
`geo_metros`	object	Metro area targeting with system-specific support
`geo_postal_areas`	object	Postal area targeting with country and precision support

geo_metros specifies which metro classification systems are supported:

System	Description
`nielsen_dma`	Nielsen DMA codes (US market, e.g., `501` for NYC)
`uk_itl1`	UK ITL Level 1 regions
`uk_itl2`	UK ITL Level 2 regions
`eurostat_nuts2`	Eurostat NUTS Level 2 regions (EU)

geo_postal_areas specifies which postal code systems are supported:

System	Description
`us_zip`	US 5-digit ZIP codes (e.g., `10001`)
`us_zip_plus_four`	US 9-digit ZIP+4 codes (e.g., `10001-1234`)
`gb_outward`	UK postcode district (e.g., `SW1`, `EC1`)
`gb_full`	UK full postcode (e.g., `SW1A 1AA`)
`ca_fsa`	Canadian Forward Sortation Area (e.g., `K1A`)
`ca_full`	Canadian full postal code (e.g., `K1A 0B1`)
`de_plz`	German Postleitzahl (e.g., `10115`)
`fr_code_postal`	French code postal (e.g., `75001`)
`au_postcode`	Australian postcode (e.g., `2000`)

portfolio

Inventory portfolio information:

Field	Type	Description
`publisher_domains`	string[]	Required. Publisher domains this seller represents
`primary_channels`	string[]	Main advertising channels
`primary_countries`	string[]	Main countries (ISO codes)
`description`	string	Markdown portfolio description
`advertising_policies`	string	Content policies and restrictions

signals

Signals protocol capabilities. Only present if signals is in supported_protocols. Reserved for future use.

governance

Governance protocol capabilities. Only present if governance is in supported_protocols. Governance agents provide property data like compliance scores, brand suitability ratings, quality metrics, and sustainability metrics.

property_features

Array of property features this governance agent can evaluate:

Field	Type	Description
`feature_id`	string	Required. Unique identifier (e.g., `mfa_score`, `coppa_certified`)
`type`	string	Required. Data type: `binary`, `quantitative`, or `categorical`
`range`	object	For quantitative: `{ min, max }`
`categories`	string[]	For categorical: valid values
`description`	string	Human-readable description
`methodology_url`	string	URL to methodology documentation

Example governance agent response:

{
  "$schema": "/schemas/protocol/get-adcp-capabilities-response.json",
  "adcp": { "major_versions": [1] },
  "supported_protocols": ["governance"],
  "governance": {
    "property_features": [
      { "feature_id": "mfa_score", "type": "quantitative", "range": { "min": 0, "max": 100 }, "description": "Made For Advertising detection (0=quality content, 100=likely MFA)", "methodology_url": "https://vendor.example.com/methodology/mfa" },
      { "feature_id": "coppa_certified", "type": "binary", "description": "COPPA compliance certification" },
      { "feature_id": "carbon_score", "type": "quantitative", "range": { "min": 0, "max": 100 }, "description": "Carbon footprint sustainability score", "methodology_url": "https://scope3.com/methodology/carbon-score" },
      { "feature_id": "content_category", "type": "categorical", "categories": ["news", "entertainment", "sports", "finance"], "description": "Primary content category" }
    ]
  }
}

extensions_supported

Array of extension namespaces this agent supports. Buyers can expect meaningful data in ext.{namespace} fields on responses from this agent.

Field	Type	Description
`extensions_supported`	string[]	Extension namespaces (e.g., `["scope3", "garm"]`)

Extension schemas are published in the AdCP extension registry. When an agent declares support for an extension, buyers know to look for and process ext.{namespace} data in responses. Example:

{
  "extensions_supported": ["scope3", "garm", "iab_tcf"]
}

This tells buyers:

Product responses may include ext.scope3 with Scope3 sustainability data
Creative policies may include ext.garm with GARM brand suitability categorizations
Responses may include ext.iab_tcf with IAB TCF consent data

The Capability Contract

If a capability is declared, the seller MUST honor it.

media_buy.execution.targeting.geo_postal_areas.us_zip: true → Buyer can send US ZIP codes, seller MUST target them
media_buy.execution.targeting.geo_metros.nielsen_dma: true → Buyer can send DMA codes, seller MUST target them
media_buy.features.content_standards: true → Seller MUST apply content standards when provided
AXE URL in media_buy.execution.axe_integrations → Seller can execute through that exchange

No silent ignoring. If a seller can’t support a capability, they should declare false or omit it.

Common Scenarios

Basic Capability Discovery

import { AdcpClient } from '@adcp/client';

const client = new AdcpClient({ baseUrl: 'https://seller.example.com/mcp' });

// Get seller capabilities
const result = await client.getAdcpCapabilities({});

if (result.errors) {
  throw new Error(`Request failed: ${result.errors[0].message}`);
}

// Check protocol support
console.log(`AdCP versions: ${result.adcp.major_versions.join(', ')}`);
console.log(`Supported protocols: ${result.supported_protocols.join(', ')}`);

// Check media-buy capabilities
if (result.supported_protocols.includes('media_buy')) {
  const mediaBuy = result.media_buy;

  // Check feature support
  if (mediaBuy.features?.content_standards) {
    console.log('Content standards supported');
  }

  // Check AXE integrations
  if (mediaBuy.execution?.axe_integrations?.includes('https://agentic.scope3.com')) {
    console.log('Scope3 AXE integration available');
  }

  // Check geo targeting
  if (mediaBuy.execution?.targeting?.geo_postal_areas?.us_zip) {
    console.log('US ZIP code targeting supported');
  }

  // Portfolio overview
  console.log(`Publishers: ${mediaBuy.portfolio.publisher_domains.length}`);
  console.log(`Channels: ${mediaBuy.portfolio.primary_channels?.join(', ')}`);
}

Filter Sellers by Capability

// Find sellers that support specific requirements
async function findCompatibleSellers(sellers, requirements) {
  const compatible = [];

  for (const sellerUrl of sellers) {
    const client = new AdcpClient({ baseUrl: sellerUrl });
    const caps = await client.getAdcpCapabilities({});

    if (caps.errors) continue;

    // Must support media_buy protocol
    if (!caps.supported_protocols.includes('media_buy')) continue;

    const mediaBuy = caps.media_buy;

    // Check AXE integration requirement
    if (requirements.axeIntegration) {
      if (!mediaBuy.execution?.axe_integrations?.includes(requirements.axeIntegration)) {
        continue;
      }
    }

    // Check geo targeting requirement
    if (requirements.postalCodeTargeting) {
      if (!mediaBuy.execution?.targeting?.geo_postal_areas?.us_zip) {
        continue;
      }
    }

    // Check feature requirement
    if (requirements.contentStandards) {
      if (!mediaBuy.features?.content_standards) {
        continue;
      }
    }

    compatible.push({ url: sellerUrl, capabilities: caps });
  }

  return compatible;
}

// Usage
const sellers = await findCompatibleSellers(
  ['https://seller1.com/mcp', 'https://seller2.com/mcp'],
  {
    axeIntegration: 'https://agentic.scope3.com',
    postalCodeTargeting: true,
    contentStandards: true
  }
);

Use Capabilities to Build Targeting

Capabilities tell you what you CAN specify in create_media_buy targeting. Use required_geo_targeting to filter products to sellers that support specific geo targeting levels and systems:

// First, check capabilities
const caps = await client.getAdcpCapabilities({});

if (!caps.supported_protocols.includes('media_buy')) {
  throw new Error('Seller does not support media_buy protocol');
}

const mediaBuy = caps.media_buy;

// Filter products to sellers with specific geo targeting capabilities
const products = await client.getProducts({
  brief: "Premium video inventory in US for ZIP-targeted campaign",
  filters: {
    channels: ['olv', 'ctv'],
    countries: ['US'],
    // Require seller supports ZIP targeting (capability filter - no actual ZIPs needed)
    // level = granularity, system = classification taxonomy
    required_geo_targeting: [
      { level: 'postal_area', system: 'us_zip' }
    ],
    // Only include if seller supports this AXE
    required_axe_integrations: ['https://agentic.scope3.com']
  }
});

// Then, create media buy with fine-grained targeting
// (if seller supports postal areas, we can target specific ZIP codes)
const buy = await client.createMediaBuy({
  buyer_ref: 'my-campaign-001',
  brand_manifest: { url: 'https://mybrand.com' },
  packages: [{
    buyer_ref: 'package-001',
    product_id: products.products[0].product_id,
    pricing_option_id: products.products[0].pricing_options[0].id,
    budget: 10000,
    // Targeting overlay refines delivery within product coverage
    targeting_overlay: {
      geo_countries: ['US'],
      // Only specify ZIP targeting if seller supports it
      ...(mediaBuy.execution?.targeting?.geo_postal_areas?.us_zip && {
        geo_postal_areas: [{
          system: 'us_zip',
          values: ['10001', '10002', '10003', '10004', '10005']
        }]
      })
    }
  }],
  start_time: { type: 'asap' },
  end_time: '2025-03-01T00:00:00Z'
});

Two models for product geography:

Inventory Type	Filter By	Example
Digital (display, OLV, CTV)	Capability: `required_geo_targeting`	Products have broad coverage, target at buy time
Local (radio, DOOH, local TV)	Coverage: `metros`, `regions`	Products ARE geographically bound

Digital inventory: Use countries + required_geo_targeting (capability), apply fine-grained targeting in create_media_buy
Local inventory: Use metros/regions (coverage) to find products with coverage in your target markets

Local Inventory Example (Radio, DOOH)

For locally-bound inventory, products ARE geographically specific. A radio station in NYC DMA only covers NYC.

// Find radio products in specific DMAs
const radioProducts = await client.getProducts({
  brief: "Radio inventory in NYC and LA markets",
  filters: {
    channels: ['radio'],
    // Coverage filter: products must cover these metros
    metros: [
      { system: 'nielsen_dma', code: '501' },  // NYC
      { system: 'nielsen_dma', code: '803' }   // LA
    ]
  }
});

// For local inventory, targeting_overlay is optional -
// the product's coverage IS the geography
const buy = await client.createMediaBuy({
  buyer_ref: 'radio-campaign-001',
  brand_manifest: { url: 'https://mybrand.com' },
  packages: [{
    buyer_ref: 'package-001',
    product_id: radioProducts.products[0].product_id,
    pricing_option_id: radioProducts.products[0].pricing_options[0].id,
    budget: 5000
    // No targeting_overlay needed - product covers NYC DMA
  }],
  start_time: { type: 'asap' },
  end_time: '2025-03-01T00:00:00Z'
});

Response Example

{
  "$schema": "/schemas/protocol/get-adcp-capabilities-response.json",
  "adcp": {
    "major_versions": [1]
  },
  "supported_protocols": ["media_buy"],
  "media_buy": {
    "features": {
      "inline_creative_management": true,
      "property_list_filtering": true,
      "content_standards": false
    },
    "execution": {
      "axe_integrations": ["https://agentic.scope3.com"],
      "creative_specs": {
        "vast_versions": ["4.0", "4.1", "4.2"],
        "mraid_versions": ["3.0"],
        "vpaid": false,
        "simid": true
      },
      "targeting": {
        "geo_countries": true,
        "geo_regions": true,
        "geo_metros": {
          "nielsen_dma": true,
          "uk_itl2": false,
          "eurostat_nuts2": false
        },
        "geo_postal_areas": {
          "us_zip": true,
          "us_zip_plus_four": false,
          "gb_outward": true,
          "gb_full": false,
          "ca_fsa": true
        }
      }
    },
    "portfolio": {
      "publisher_domains": ["example.com", "news.example.com"],
      "primary_channels": ["display", "olv"],
      "primary_countries": ["US", "CA"]
    }
  },
  "extensions_supported": ["scope3"],
  "last_updated": "2025-01-23T10:00:00Z"
}

This tells buyers:

AdCP versions: Version 1
Protocols: Media-buy only (signals not supported)
Country targeting: Available (ISO 3166-1 alpha-2: US, GB, etc.)
Region targeting: Available (ISO 3166-2: US-NY, GB-SCT, etc.)
Metro targeting: Nielsen DMA only (US market)
Postal targeting: US ZIP, UK outward codes, Canadian FSA
Extensions: Scope3 sustainability data in ext.scope3

Geo Standards Reference

Level	System	Examples
Country	ISO 3166-1 alpha-2	`US`, `GB`, `DE`, `CA`
Region	ISO 3166-2	`US-NY`, `GB-SCT`, `DE-BY`, `CA-ON`
Metro (US)	`nielsen_dma`	`501` (NYC), `803` (LA), `602` (Chicago)
Metro (UK)	`uk_itl2`	`UKI` (London), `UKD` (North West)
Metro (EU)	`eurostat_nuts2`	`DE30` (Berlin), `FR10` (Île-de-France)
Postal (US)	`us_zip`	`10001`, `90210`
Postal (US)	`us_zip_plus_four`	`10001-1234`
Postal (UK)	`gb_outward`	`SW1`, `EC1`, `M1`
Postal (UK)	`gb_full`	`SW1A 1AA`
Postal (CA)	`ca_fsa`	`K1A`, `M5V`

Migration from list_authorized_properties (v2)

The list_authorized_properties task was removed in v3. If migrating from v2:

Old Field	New Location
`publisher_domains`	`media_buy.portfolio.publisher_domains`
`primary_channels`	`media_buy.portfolio.primary_channels`
`primary_countries`	`media_buy.portfolio.primary_countries`
`portfolio_description`	`media_buy.portfolio.description`
`advertising_policies`	`media_buy.portfolio.advertising_policies`
`last_updated`	`last_updated` (top level)

New fields:

adcp.major_versions - Version compatibility
supported_protocols - Which domain protocols are supported
media_buy.features - Optional feature support
media_buy.execution.axe_integrations - Ad exchange support
media_buy.execution.creative_specs - VAST/MRAID versions
media_buy.execution.targeting - Geo targeting granularity

Error Handling

Error Code	Description	Resolution
`AUTH_REQUIRED`	Authentication needed	Provide credentials
`INTERNAL_ERROR`	Server error	Retry with backoff

Best Practices

1. Cache Capabilities Capabilities rarely change. Cache results and use last_updated for staleness detection. 2. Check Protocol Support First Before accessing protocol-specific fields, verify the protocol is in supported_protocols. 3. Check Before Requesting Don’t send postal areas for a system the seller doesn’t support. Don’t request features the seller doesn’t support. 4. Fail Fast on Incompatibility If a seller doesn’t support required capabilities, skip them early rather than discovering failures later. 5. Use Protocol Version for Routing Route requests to appropriate API versions based on adcp.major_versions.

Next Steps

After discovering capabilities:

Filter products: Use get_products with capability-aware filters
Validate properties: Fetch publisher adagents.json files for property definitions
Create buys: Use create_media_buy with supported features

Learn More

adagents.json Specification - Publisher authorization files
Product Filters - Capability-aware filtering
Content Standards - Brand safety configuration

Getting Started

Building with AdCP

Governance Protocol

Brand Protocol

Signals Protocol

Curation Protocol

Sponsored Intelligence Protocol

Media Buy Protocol

Creative

Reference

Community

Tool-Based Discovery

Request Parameters

Response Structure

adcp

supported_protocols

media_buy

features

execution

creative_specs

targeting

portfolio

signals

governance

property_features

extensions_supported

The Capability Contract

Common Scenarios

Basic Capability Discovery

Filter Sellers by Capability

Use Capabilities to Build Targeting

Local Inventory Example (Radio, DOOH)

Response Example

Geo Standards Reference

Migration from list_authorized_properties (v2)

Error Handling

Best Practices

Next Steps

Learn More

Getting Started

Building with AdCP

Governance Protocol

Brand Protocol

Signals Protocol

Curation Protocol

Sponsored Intelligence Protocol

Media Buy Protocol

Creative

Reference

Community

​Tool-Based Discovery

​Request Parameters

​Response Structure

​adcp

​supported_protocols

​media_buy

​features

​execution

creative_specs

targeting

​portfolio

​signals

​governance

​property_features

​extensions_supported

​The Capability Contract

​Common Scenarios

​Basic Capability Discovery

​Filter Sellers by Capability

​Use Capabilities to Build Targeting

​Local Inventory Example (Radio, DOOH)

​Response Example

​Geo Standards Reference

​Migration from list_authorized_properties (v2)

​Error Handling

​Best Practices

​Next Steps

​Learn More

Tool-Based Discovery

Request Parameters

Response Structure

adcp

supported_protocols

media_buy

features

execution

portfolio

signals

governance

property_features

extensions_supported

The Capability Contract

Common Scenarios

Basic Capability Discovery

Filter Sellers by Capability

Use Capabilities to Build Targeting

Local Inventory Example (Radio, DOOH)

Response Example

Geo Standards Reference

Migration from list_authorized_properties (v2)

Error Handling

Best Practices

Next Steps

Learn More