AdCP — Introduction to the Protocol

AdCP 3.0 Release Candidate 2You’re viewing the 3.0-rc.2 documentation. Schemas may still change before the final 3.0 release. See what’s new in rc.2 and the AdCP 3.0 overview. For production use, switch to version 2.5 using the version selector above.

Alex stands arms crossed in a war room of mismatched screens and tangled cables, surveying the chaos — her team hunched over laptops in the background

Alex runs media operations at Pinnacle Agency. Her team buys across six channels — CTV, display, audio, social, retail media, and digital out-of-home. Each channel has its own buying methods, its own terminology, its own way of handling creatives, targeting, and reporting. IOs for some. APIs for others. DSPs for programmatic. Dashboards for everything. Now her clients want to try AI-generated creative, influencer campaigns, and local radio. Each new channel means new tools, new integrations, new workflows to learn. She can’t keep scaling her team every time a client wants to try something new. The problem isn’t her people. It’s that every channel speaks a different language, and the industry has no common standard for how agents discover inventory, execute buys, distribute creative, activate data, or report results. AdCP is that standard. One protocol. Every platform. Every step of the campaign. This page follows Alex’s team through the entire workflow — from finding new partners to measuring results. Each section shows the human problem, the protocol solution, and the tasks that make it work. By the end, you’ll understand every domain AdCP covers and how they connect.

Find new partners

Alex reaches toward a glowing network map on a wall display, about to select a new publisher node from a constellation of connected partners

Alex wants to work with publishers she’s never talked to before. In the old world, that means sales calls, contracts, and weeks of integration work before she can even see what’s available. With AdCP, discovery is built into the protocol. Every AdCP-enabled publisher hosts an adagents.json file — a machine-readable declaration of their properties, capabilities, and authorized agents. Alex’s buyer agent reads it the same way a browser reads robots.txt.

https://streamhaus.tv/.well-known/adagents.json

{
  "version": "1.0",
  "publisher": {
    "name": "StreamHaus",
    "domain": "streamhaus.tv"
  },
  "agents": [
    {
      "url": "https://ads.streamhaus.tv/mcp",
      "protocol": "mcp",
      "capabilities": ["get_products", "create_media_buy", "sync_creatives"]
    }
  ]
}

For broader discovery — “find me CTV publishers with sports inventory” — the AgenticAdvertising.org registry provides entity resolution and agent search. Alex’s agent can query the registry by category, geography, or capability, and get back a list of publishers to connect with.

What the registry returns

The registry API resolves brands to their AdCP agents:

GET /api/registry/agents?capability=get_products&channel=ctv

{
  "agents": [
    {
      "domain": "streamhaus.tv",
      "agent_url": "https://ads.streamhaus.tv/mcp",
      "capabilities": ["get_products", "create_media_buy"],
      "channels": ["ctv", "olv"]
    }
  ]
}

Learn more: adagents.json

How publishers declare their properties and authorized agents.

Set up accounts

Sam shakes hands across a desk with a laptop showing a teal checkmark between them — setting up a new commercial relationship

Before Alex’s team can buy media, they need a commercial relationship. In the old world, each platform has different onboarding — portals, forms, sales reps, weeks of back-and-forth. AdCP standardizes this with the accounts protocol. Sam, Alex’s media buyer, sets up Pinnacle’s relationship with StreamHaus in one call:

{
  "$schema": "https://adcontextprotocol.org/schemas/v3/account/sync-accounts-request.json",
  "accounts": [
    {
      "brand": { "domain": "acmeoutdoor.com" },
      "operator": "pinnacle-agency.com",
      "billing": "operator"
    }
  ]
}

The seller responds with the account status — active, pending review, or what additional information is needed. Once active, Sam can buy media. list_accounts shows all active relationships across every platform, so Alex can see at a glance which publishers her team is set up with.

Deep dive: Accounts

Commercial identity, billing models, and multi-advertiser management.

Discover what’s available

Sam gestures at three product cards on a wall screen — CTV, display, and audio inventory options all generated from one campaign brief

This is where it gets powerful. Sam wants to find premium sports inventory for Acme Outdoor’s Q2 campaign. In the old world, he’d log into four dashboards and compare apples to oranges. With AdCP, get_products sends the same brief to every connected seller. Sam describes what he wants in natural language:

{
  "$schema": "https://adcontextprotocol.org/schemas/v3/media-buy/get-products-request.json",
  "buying_mode": "brief",
  "brief": "Premium sports video inventory, Q2 2026, targeting 25-45 males interested in outdoor recreation. Budget $50K across CTV and display.",
  "brand": { "domain": "acmeoutdoor.com" }
}

Every seller responds in the same format — products with pricing, forecasts, targeting options, and creative requirements. Sam compares proposals side by side on one screen instead of four.

What a product response looks like

{
  "products": [
    {
      "product_id": "streamhaus_sports_ctv_q2",
      "name": "StreamHaus Sports Premium",
      "channels": ["ctv"],
      "pricing_options": [
        {
          "model": "cpm",
          "price": 28.50,
          "currency": "USD"
        }
      ],
      "forecast": {
        "impressions": { "min": 500000, "max": 750000 }
      },
      "format_ids": [
        { "agent_url": "https://ads.streamhaus.tv", "id": "video_16x9_30s" }
      ]
    }
  ]
}

But Sam isn’t done. He likes StreamHaus’s sports package but wants to shift budget toward CTV and drop the display allocation. Instead of starting over, he uses refine mode — an iterative conversation with the seller:

{
  "$schema": "https://adcontextprotocol.org/schemas/v3/media-buy/get-products-request.json",
  "buying_mode": "refine",
  "refine": [
    {
      "scope": "product",
      "id": "streamhaus_sports_ctv_q2",
      "action": "more_like_this",
      "ask": "More CTV inventory like this, willing to go up to $35 CPM"
    },
    {
      "scope": "request",
      "ask": "Drop display entirely, reallocate budget to CTV and OLV"
    }
  ]
}

The seller adjusts and responds with refined options. No new RFP. No starting from scratch. Sam iterates until he has exactly what he wants.

Follow Sam's full journey

The complete media buy walkthrough — brief to delivery across three sellers.

Build the creative

Maya sits in a creative studio with her iPad, surrounded by wall screens showing ad formats of different sizes all generated from one brief

Maya, Pinnacle’s creative strategist, needs to produce ads for Sam’s campaign. One campaign, three sellers, six formats — CTV video, OLV pre-roll, display banners, companion ads. In the old world, that’s six separate production workflows. First, Maya discovers what each seller accepts:

{
  "$schema": "https://adcontextprotocol.org/schemas/v3/creative/list-creative-formats-request.json",
  "type": "video"
}

Each seller returns their supported formats with exact specifications — dimensions, codecs, file sizes, duration limits. No guessing. Then Maya briefs the creative agent. One brief produces all formats:

{
  "$schema": "https://adcontextprotocol.org/schemas/v3/media-buy/build-creative-request.json",
  "message": "Adventurous, aspirational summer campaign — gear for people who live outside",
  "brand": { "domain": "acmeoutdoor.com" },
  "target_format_ids": [
    { "agent_url": "https://ads.streamhaus.tv", "id": "video_16x9_30s" },
    { "agent_url": "https://ads.streamhaus.tv", "id": "display_300x250" }
  ]
}

The creative agent pulls Acme Outdoor’s brand identity — colors, logos, tone guidelines — directly from the brand’s brand.json (more on that below). No brand guide PDFs. No manual asset handoff. If Maya doesn’t like the first draft, she refines with natural language: “Make the opening shot more dynamic and swap the product shot for the hiking boots.” The build_creative task supports iterative refinement — same task, conversational guidance. Once approved, sync_creatives distributes the finished assets to every seller simultaneously:

{
  "$schema": "https://adcontextprotocol.org/schemas/v3/creative/sync-creatives-request.json",
  "account": { "brand": { "domain": "acmeoutdoor.com" }, "operator": "pinnacle-agency.com" },
  "creatives": [
    {
      "creative_id": "acme_summer_ctv_30s",
      "name": "Acme Summer CTV 30s",
      "format_id": { "agent_url": "https://ads.streamhaus.tv", "id": "video_16x9_30s" },
      "assets": {
        "video": { "url": "https://cdn.pinnacle.com/acme_summer_30s.mp4", "width": 1920, "height": 1080, "duration_ms": 30000 }
      }
    }
  ]
}

Follow Maya's full journey

Creative generation, format discovery, and multi-seller distribution.

Execute the buy

Sam presses a launch button on his laptop with a teal pulse radiating from the screen, Alex standing behind him arms crossed with a satisfied smile

Sam has products, creatives, and accounts. Time to buy. One call to create_media_buy executes the campaign across every seller:

{
  "$schema": "https://adcontextprotocol.org/schemas/v3/media-buy/create-media-buy-request.json",
  "buyer_ref": "acme_outdoor_summer_q2",
  "account": { "brand": { "domain": "acmeoutdoor.com" }, "operator": "pinnacle-agency.com" },
  "brand": { "domain": "acmeoutdoor.com" },
  "start_time": "2026-04-01T00:00:00Z",
  "end_time": "2026-06-30T23:59:59Z",
  "packages": [
    {
      "buyer_ref": "pkg_streamhaus_ctv",
      "product_id": "streamhaus_sports_ctv_q2",
      "budget": 35000,
      "pricing_option_id": "cpm_standard"
    }
  ]
}

For sellers that generate creative — AI assistants, conversational ad platforms — the media buy can include a brief instead of pre-built assets. The seller’s creative agent generates on the fly, pulling from the brand identity and campaign context. Both models — provided creative and generative creative — use the same create_media_buy task. update_media_buy handles mid-flight changes: shift budget between packages, adjust flight dates, swap creative assignments. No need to cancel and recreate.

Add your data

Sam and Kai sit side by side with laptops as translucent teal data streams arc between their screens — combining campaign and signal data

Sam’s campaign needs targeting beyond what the sellers provide. His client has CRM data (existing customers to exclude), Pinnacle has audience segments from their DMP, and he wants to layer on third-party signals from Kai’s data company, Meridian Geo. Audiences travel with the campaign via sync_audiences:

{
  "$schema": "https://adcontextprotocol.org/schemas/v3/media-buy/sync-audiences-request.json",
  "account": { "brand": { "domain": "acmeoutdoor.com" }, "operator": "pinnacle-agency.com" },
  "audiences": [
    {
      "audience_id": "acme_existing_customers",
      "name": "Acme Outdoor — existing customers",
      "audience_type": "suppression"
    }
  ]
}

Signals — third-party targeting data — are discovered and activated through the signals protocol. Sam searches for what he needs:

{
  "$schema": "https://adcontextprotocol.org/schemas/v3/signals/get-signals-request.json",
  "signal_spec": "Outdoor recreation enthusiasts near sporting goods retailers, 25-45"
}

Kai’s Meridian Geo returns matching signal segments with pricing, coverage, and activation options. Sam activates the ones he wants:

{
  "$schema": "https://adcontextprotocol.org/schemas/v3/signals/activate-signal-request.json",
  "signal_agent_segment_id": "meridian_outdoor_rec_25_45",
  "destinations": [
    { "type": "platform", "platform": "streamhaus" }
  ]
}

The signal activates on StreamHaus’s platform. Kai’s data reaches Sam’s campaign without either side building a custom integration.

Signals deep dive

How Sam discovers and activates Kai’s targeting data across platforms.

Govern it

Jordan studies a governance approval chain on her tablet, silver hoop earrings catching the lamplight, her expression focused and deliberate

Before any of Sam’s campaigns go live, they pass through governance. Jordan, Pinnacle’s campaign ops manager, set up the governance framework before Alex let any agent spend money. check_governance runs automatically before execution — budget limits, brand safety, targeting compliance:

{
  "$schema": "https://adcontextprotocol.org/schemas/v3/governance/check-governance-request.json",
  "plan_id": "acme_outdoor_q2_plan",
  "buyer_campaign_ref": "AcmeOutdoor_Summer_Q2",
  "binding": "proposed",
  "caller": "https://buyer.pinnacle-agency.com/a2a",
  "tool": "create_media_buy",
  "payload": {
    "buyer_ref": "acme_outdoor_summer_q2",
    "brand": { "domain": "acmeoutdoor.com" },
    "start_time": "2026-04-01T00:00:00Z",
    "end_time": "2026-06-30T23:59:59Z"
  }
}

If everything passes, the campaign proceeds. If something exceeds the agent’s authority — say, the budget is above Jordan’s $20K auto-approval threshold — the governance agent escalates to a human. Jordan reviews, adds conditions if needed, and approves. The agent can’t skip this step; it’s architectural, not procedural. After the campaign runs, get_plan_audit_logs provides the complete decision trail — who proposed what, who approved it, what conditions were attached, what actually ran. Every decision is recorded and attributable.

What an audit log looks like

{
  "entries": [
    {
      "timestamp": "2026-03-15T14:30:00Z",
      "actor": "buyer_agent",
      "action": "submit_plan",
      "details": { "budget": 50000, "channels": ["ctv", "olv"] }
    },
    {
      "timestamp": "2026-03-15T14:30:01Z",
      "actor": "governance_agent",
      "action": "escalate",
      "reason": "Budget exceeds auto-approval threshold ($20,000)"
    },
    {
      "timestamp": "2026-03-15T15:12:00Z",
      "actor": "[email protected]",
      "action": "approve_with_conditions",
      "conditions": ["Weekly spend cap of $15,000", "CTV only — no OLV until brand safety review"]
    }
  ]
}

Follow Jordan's full journey

The governance walkthrough — from nightmare to audit trail.

Track performance

Sam stands before a large performance dashboard with trending charts, coffee in hand, turning back with a confident expression — everything is on track

Sam’s campaign is live. In the old world, he’d check four dashboards. Now, get_media_buy_delivery aggregates performance from every seller into one response:

{
  "impressions": 1250000,
  "clicks": 18750,
  "spend": { "amount": 34200, "currency": "USD" },
  "by_package": [
    {
      "product_id": "streamhaus_sports_ctv_q2",
      "impressions": 750000,
      "completion_rate": 0.87
    }
  ]
}

For deeper performance tracking, AdCP provides two more tools: log_event records marketing events — purchases, leads, sign-ups — back to the sellers for attribution and optimization:

{
  "$schema": "https://adcontextprotocol.org/schemas/v3/media-buy/log-event-request.json",
  "event_source_id": "acme_website_pixel",
  "events": [
    {
      "event_id": "evt_abc123",
      "event_type": "purchase",
      "event_time": "2026-05-15T10:30:00Z",
      "action_source": "website",
      "custom_data": { "value": 149.99, "currency": "USD" }
    }
  ]
}

provide_performance_feedback closes the optimization loop — telling sellers what’s working and what isn’t, so their algorithms can adjust:

{
  "$schema": "https://adcontextprotocol.org/schemas/v3/media-buy/provide-performance-feedback-request.json",
  "buyer_ref": "acme_outdoor_summer_q2",
  "measurement_period": {
    "start": "2026-04-01T00:00:00Z",
    "end": "2026-04-30T23:59:59Z"
  },
  "performance_index": 1.35
}

Connect your store

Overhead view of a phone showing a product catalog connected by a glowing teal line to a laptop campaign interface — catalog data flowing between them

Acme Outdoor has a Shopify store with 200 products. They want their catalog available to AI platforms — AI assistants that recommend products, AI search engines that surface them, retail media networks that need feed data. sync_catalogs pushes the product feed to every connected platform:

{
  "$schema": "https://adcontextprotocol.org/schemas/v3/media-buy/sync-catalogs-request.json",
  "account": { "brand": { "domain": "acmeoutdoor.com" }, "operator": "pinnacle-agency.com" },
  "catalogs": [
    {
      "catalog_id": "acme_outdoor_products",
      "name": "Acme Outdoor Product Feed",
      "type": "product",
      "url": "https://acmeoutdoor.com/feeds/products.json",
      "feed_format": "shopify",
      "update_frequency": "daily"
    }
  ]
}

The seller ingests the catalog and makes it available for product-level targeting, dynamic creative, and conversational recommendations. When a product goes out of stock or a price changes, the feed updates and the seller syncs automatically.

Protect the brand

Tomoko manages brand operations at Acme Outdoor’s parent company, Nova Motors. She published Nova’s brand.json — a machine-readable brand identity that AI agents consume directly:

https://novamotors.com/.well-known/brand.json

{
  "$schema": "https://adcontextprotocol.org/schemas/v3/brand.json",
  "house": {
    "domain": "novamotors.com",
    "name": "Nova Motors"
  },
  "brands": [
    {
      "id": "acme_outdoor",
      "names": [{ "en": "Acme Outdoor" }],
      "identity_agent": {
        "url": "https://brand.novamotors.com/mcp",
        "id": "nova_brand_agent"
      }
    }
  ]
}

When Maya’s creative agents generate ads, they pull brand guidelines directly from brand.json and the get_brand_identity task — colors, logos, tone, visual guidelines. No brand guide PDF. No manual asset handoff. The brand controls what AI agents see, and the protocol enforces it. For campaigns using licensed talent or third-party IP, the brand protocol handles rights licensing — discovery, acquisition, creative approval, and lifecycle management, all through the same protocol.

Brand protocol

Brand identity, rights licensing, and how brands control what AI does with their assets.

The full picture

Alex started with twelve platforms, twelve integrations, and a team drowning in platform mechanics. Now her team works through one protocol:

What they need	How AdCP handles it	Key tasks
Find new partners	Publisher discovery + registry	`adagents.json`, Registry API
Set up relationships	Standardized onboarding	`sync_accounts`, `list_accounts`
Discover inventory	One brief, every seller	`get_products` (brief + refine modes)
Build creative	One brief, every format	`build_creative`, `list_creative_formats`, `sync_creatives`
Execute campaigns	One buy, multiple sellers	`create_media_buy`, `update_media_buy`
Add targeting data	Audiences + third-party signals	`sync_audiences`, `get_signals`, `activate_signal`
Govern everything	Human oversight, built in	`check_governance`, `get_plan_audit_logs`
Track performance	Unified reporting + events	`get_media_buy_delivery`, `log_event`
Connect commerce	Product catalog sync	`sync_catalogs`
Protect the brand	Machine-readable identity	`brand.json`, `get_brand_identity`

Sam buys media. Maya builds creative. Jordan governs. Kai provides data. Tomoko protects the brand. They all speak the same protocol.

How it works underneath

AdCP doesn’t assume a single AI handles everything. Specialized agents handle what they’re best at:

Media buying agents discover inventory and execute campaigns
Creative agents generate and adapt ads across formats
Signals agents find and activate audiences
Governance agents enforce brand safety and compliance
Orchestrators coordinate the workflow and make sure humans approve what matters

These agents communicate over two transport protocols: MCP (for AI assistants calling tools) and A2A (for agent-to-agent collaboration). Same tasks, same schemas, different transport.

Brief to live ads

Here’s what Alex’s team does now:

Write a brief: “Find premium video inventory on sports publishers for Q2 with a $50K budget”
Agents discover options: get_products goes to every connected seller simultaneously
Compare proposals: Products come back in a standard format — pricing, forecasts, targeting — all comparable
Agents build creatives: build_creative adapts assets to each seller’s formats
Approve and launch: create_media_buy executes across platforms in one call
Monitor delivery: get_media_buy_delivery aggregates performance from every seller into one view

Each step uses a standard AdCP task with a JSON Schema-defined request and response. No platform-specific code. No manual translation between systems.

Trust through governance

When AI agents spend money autonomously, trust requires structure. AdCP’s governance layer provides it:

Before a campaign launches: check_governance validates budget limits, brand safety, and regulatory compliance
If something exceeds authority: The governance agent escalates to a human — your team approves, not the AI
While campaigns run: Governance agents monitor delivery against approved parameters
After delivery: get_plan_audit_logs provides a complete decision trail — who proposed what, who approved it, what actually ran

Governance isn’t a gate that slows things down. It’s the safety net that lets you give agents more autonomy over time.

Where do you want to start?

I want to buy on AI platforms

For brands, agencies, and businesses who want to advertise on AI surfaces

I want to build with AdCP

For platforms, publishers, and developers implementing the protocol

Get started

Ask Addie

Ask questions about AdCP, explore the protocol, and test tasks — no code required

Client SDKs

JavaScript and Python libraries with CLI tools for testing

Brand.json builder

Create and validate your brand’s brand.json file

AdAgents.json builder

Validate or create your publisher’s adagents.json file

Registry

Browse registered agents, brands, and publishers

Building with AdCP

Choose between MCP and A2A, learn implementation patterns

See it in action

Media buy

Follow Sam through a complete campaign — brief to delivery

Creative

Follow Maya through creative generation and distribution

Governance

Follow Jordan through the trust model that protects your spend

For platform providers

AI is buying ads. Make sure it can buy yours. If you operate a DSP, SSP, publisher, data platform, creative platform, governance service, or any ad tech solution, AdCP lets AI agents discover and transact with your platform. To get started:

Implement an AdCP agent — Expose your platform’s capabilities as AdCP tasks over MCP or A2A. Start with get_adcp_capabilities.
Publish your adagents.json — Declare your properties and authorized agents so buyers can discover you.
Test your implementation — Validate with Addie or the client SDKs.

Implement the protocol domains relevant to your business:

Publishers and SSPs: Media Buy and adagents.json
Data providers: Signals and data provider guide
Creative platforms: Creative
Governance vendors: Governance protocol
Brands: Brand Protocol and brand.json

For advertisers and agencies

Run campaigns across more platforms without scaling your team. AdCP-enabled agents work across all your media partners through a single interface — the same tasks buy CTV inventory, activate audience data, and manage creatives regardless of which platform you’re working with.

Read the buyer’s guide — The monetizing AI guide explains how this works for brands, agencies, and SMBs.
Check platform support — See which of your media partners support AdCP, or browse the registry.
Try it with Addie — Ask Addie to walk you through the protocol — no code required.
Build your own agent — No engineering team required. The certification program teaches anyone to build a working advertising agent through vibe coding — describe what you want, an AI coding assistant writes the code.
Connect with your team — Share the building guide and client SDKs with your technical team to start integrating.

Client libraries

npm install @adcp/client

NPM: @adcp/client | GitHub
PyPI: adcp | GitHub

Reference implementations

Organization

AdCP is a project of AgenticAdvertising.org, an industry organization of publishers, platforms, agencies, and technology providers advancing open standards for AI-powered advertising. Members join AgenticAdvertising.org to develop and adopt the protocol.

Need help?

Browse the documentation
Ask in Slack Community
Email: [email protected]

Documentation

​Find new partners

Learn more: adagents.json

​Set up accounts

Deep dive: Accounts

​Discover what’s available

Follow Sam's full journey

​Build the creative

Follow Maya's full journey

​Execute the buy

​Add your data

Signals deep dive

​Govern it

Follow Jordan's full journey

​Track performance

​Connect your store

​Protect the brand

Brand protocol

​The full picture

​How it works underneath

​Brief to live ads

​Trust through governance

​Where do you want to start?

I want to buy on AI platforms

I want to build with AdCP

​Get started

Ask Addie

Client SDKs

Brand.json builder

AdAgents.json builder

Registry

Building with AdCP

​See it in action

Media buy

Creative

Governance

​For platform providers

​For advertisers and agencies

​Client libraries

​Reference implementations

​Organization

​Need help?

Find new partners

Set up accounts

Discover what’s available

Build the creative

Execute the buy

Add your data

Govern it

Track performance

Connect your store

Protect the brand

The full picture

How it works underneath

Brief to live ads

Trust through governance

Where do you want to start?

Get started

See it in action

For platform providers

For advertisers and agencies

Client libraries

Reference implementations

Organization

Need help?