adcp-advertising – OpenClaw Skill

---

name: adcp-advertising displayName: AdCP Advertising description: Automate advertising campaigns with AI. Create ads, buy media, manage ad budgets, discover ad inventory, run display ads, video ads, CTV campaigns, and optimize ad performance. Perfect for marketing automation, programmatic advertising, media buying, ad management, campaign optimization, creative management, and performance tracking. Launch Facebook ads, Google ads, display advertising, video marketing, and multi-channel campaigns using natural language. Supports ad targeting, audience segmentation, ROI tracking, and automated bidding. author: AdCP Community license: MIT homepage: https://docs.adcontextprotocol.org repository: https://github.com/edyyy62/openclaw-adcp category: advertising subcategory: marketing-automation type: agent keywords:

• advertising
• ads
• marketing
• campaigns
• adcp
• programmatic
• media-buying
• display-ads
• video-ads
• facebook-ads
• google-ads
• ctv
• connected-tv
• marketing-automation
• ad-management
• campaign-optimization
• targeting
• roi-tracking
• performance-marketing
• retargeting

---

Ad Context Protocol (AdCP) Advertising Skill

Overview

Automate your advertising campaigns with AI. This skill enables OpenClaw agents to discover ad inventory, launch campaigns, manage creatives, and optimize performance across display, video, CTV, audio, and more - all through natural language commands.

No dashboards. No forms. No ad platform expertise required.

What You Can Do

• 🎯 Launch campaigns in minutes - "Create a $10k display campaign targeting tech professionals in California"
• 🔍 Discover ad inventory instantly - "Find premium video placements for luxury brands"
• 🎨 Upload ads with ease - "Upload these banner images as creatives"
• 📊 Track ROI in real-time - "Show me campaign performance and CTR by creative"
• 🎛️ Auto-optimize spend - "Reallocate budget to top-performing packages"
• 🌐 Target precisely - Demographics, behaviors, interests, locations, devices, times

Perfect For

Marketing teams running Facebook ads, Google ads, and multi-channel campaigns
Media buyers managing programmatic ad spend across publishers
Agencies automating client campaign management and reporting
E-commerce brands launching product ads and retargeting campaigns
Startups running lean marketing with AI-powered automation

Why Choose This Skill?

Skip the learning curve - No need to master complex ad platforms
Save time - Launch in 5 minutes vs. hours of manual setup
Spend smarter - AI automatically optimizes budgets to top performers
Scale faster - Manage unlimited campaigns through simple commands
Test risk-free - Public test agent included, no setup required

Official AdCP Repository: https://github.com/adcontextprotocol/adcp
Official AdCP Documentation: https://docs.adcontextprotocol.org
Complete Documentation Index: https://docs.adcontextprotocol.org/llms.txt

When to Use This Skill

Trigger this skill when users ask about:

Campaign Management

• "Create a display ad campaign"
• "Launch Facebook ads for my product"
• "Set up a $5000 video advertising campaign"
• "Pause my underperforming campaigns"

Ad Discovery & Media Buying

• "Find advertising inventory for luxury brands"
• "Show me CTV ad placements in major cities"
• "What display ad options are available?"
• "Buy media for a tech startup"

Creative Management

• "Upload these banner images"
• "Which creative is performing best?"
• "Add video ads to my campaign"
• "Manage my ad library"

Performance & Optimization

• "How is my campaign performing?"
• "Show me ROI by channel"
• "Optimize my ad spend"
• "Reallocate budget to top performers"
• "Track impressions and click-through rates"

Targeting & Audiences

• "Target professionals in California"
• "Set up demographic targeting"
• "Create a retargeting campaign"
• "Target by device type and time of day"

Quick Start

Launch Your First Campaign (5 Minutes)

No setup required. Use the included test agent to try everything:

Step 1: Discover what's available

"Show me advertising capabilities"

Browse available channels, publishers, and formats.

Step 2: Find ad inventory

"Find display ads for a tech startup, budget $5000"

AI searches and shows matching products with pricing.

Step 3: Launch campaign

"Create campaign with Product prod_123, $5000 budget, targeting California tech professionals"

Campaign goes live instantly.

Step 4: Upload your ads

"Upload these banner images as creatives"

Drop files, get instant creative IDs.

Step 5: Monitor performance

"Show campaign metrics and ROI"

Real-time impressions, clicks, CTR, spend.

Real-World Usage Examples

Quick campaign launch:

User: "I need to run display ads for my SaaS product"
Agent: [Discovers products] "Found 5 display packages. Want details?"
User: "Create campaign with Product 1, $10k budget, target CTOs"
Agent: [Creates campaign] "Campaign live! ID: mb_abc123"

Performance optimization:

User: "How are my video ads performing?"
Agent: [Shows metrics] "Package A: 2.3% CTR, Package B: 0.8% CTR"
User: "Move $5k from B to A"
Agent: [Reallocates] "Budget updated. Package A now $15k"

Multi-channel campaign:

User: "Launch omnichannel campaign: display in CA, video in NYC, $50k total"
Agent: [Creates packages] "3 packages created across display and video"

How It Works

Natural Language Understanding

Speak naturally. The skill understands:

• Budgets: "$5000", "five thousand dollars", "5k budget"
• Locations: "California", "major US cities", "New York and LA"
• Audiences: "tech professionals", "age 25-45", "high income"
• Goals: "brand awareness", "drive conversions", "increase sales"

Progressive Workflow

1. Discovery Phase

"Find video advertising for luxury brands"

↓ Agent searches inventory ↓ Shows matched products with pricing ↓ Explains targeting and formats

2. Campaign Creation

"Create campaign with Product 1, $25k, target professionals"

↓ Agent creates media buy ↓ Sets up targeting overlay ↓ Returns campaign ID and status

3. Creative Management

"Upload my banner ads"

↓ Agent syncs creatives ↓ Assigns to campaign ↓ Returns creative IDs

4. Monitoring & Optimization

"Show performance"

↓ Agent fetches delivery data
↓ Shows metrics by package/creative
↓ Suggests optimizations

Core Operations

Create Campaign

const campaign = await testAgent.createMediaBuy({
  buyer_ref: 'campaign-2026-q1',
  brand_manifest: { url: 'https://acme.com' },
  packages: [{ product_id: 'premium_display', budget: 10000 }]
});

Upload Creatives

await testAgent.syncCreatives({
  creatives: [{ 
    buyer_ref: 'banner-300x250',
    url: 'https://cdn.acme.com/banner.jpg'
  }]
});

Monitor Performance

const delivery = await testAgent.getMediaBuyDelivery({
  media_buy_id: 'mb_abc123'
});
console.log(`CTR: ${delivery.totals.ctr}%, Spend: $${delivery.totals.spend}`);

See REFERENCE.md for complete API docs and EXAMPLES.md for detailed workflows.

Core Concepts

The 8 Media Buy Tasks

AdCP provides 8 standardized tasks for the complete advertising lifecycle. Learn more in the Media Buy Protocol documentation.

1. get_adcp_capabilities - Discover agent features and portfolio (~1s)
2. get_products - Find inventory using natural language (~60s)
3. list_creative_formats - View creative specifications (~1s)
4. create_media_buy - Launch campaigns (minutes-days, may require approval)
5. update_media_buy - Modify campaigns (minutes-days)
6. sync_creatives - Upload creative assets (minutes-days)
7. list_creatives - Query creative library (~1s)
8. get_media_buy_delivery - Track performance (~60s)

Complete task reference: https://docs.adcontextprotocol.org/docs/media-buy/task-reference/

Brand Manifest

Brand context can be provided two ways:

URL reference (recommended - agent fetches brand info):

{
  "brand_manifest": {
    "url": "https://brand.com"
  }
}

Inline manifest (full brand details):

{
  "brand_manifest": {
    "name": "Brand Name",
    "url": "https://brand.com",
    "tagline": "Brand tagline",
    "colors": { "primary": "#FF0000" },
    "logo": { "url": "https://cdn.brand.com/logo.png" }
  }
}

Pricing Models

Products support various pricing models:

• CPM (Cost Per Mille/Thousand) - Fixed price per 1000 impressions
• CPM-Auction - Bid-based pricing for impressions
• CPCV (Cost Per Completed View) - Video completions
• Flat-Fee - Fixed campaign cost
• CPP (Cost Per Point) - Percentage of audience reached

For auction pricing, include bid_price in your package.

Asynchronous Operations

AdCP is not a real-time protocol. Operations may take:

• ~1 second - Simple lookups (formats, creative lists)
• ~60 seconds - AI/inference operations (product discovery)
• Minutes to days - Operations requiring human approval (campaign creation)

Always check the status field in responses:

• completed - Operation finished successfully
• pending - Awaiting approval or processing
• failed - Operation failed (check error details)

Targeting Capabilities

Apply targeting overlays to campaigns:

{
  targeting_overlay: {
    geo: {
      included: ['US-CA', 'US-NY'],  // DMA codes or regions
      excluded: ['US-TX']
    },
    demographics: {
      age_ranges: [{ min: 25, max: 44 }],
      genders: ['M', 'F']
    },
    behavioral: {
      interests: ['technology', 'gaming'],
      purchase_intent: ['consumer_electronics']
    },
    contextual: {
      keywords: ['innovation', 'design'],
      categories: ['IAB19'] // Technology & Computing
    }
  }
}

Common Workflows

Workflow 1: Campaign Discovery to Launch

// 1. Discover capabilities
const caps = await agent.getAdcpCapabilities({});

// 2. Find products
const products = await agent.getProducts({
  brief: 'Q1 2026 brand awareness campaign for tech startup',
  brand_manifest: { url: 'https://startup.com' },
  filters: { channels: ['display', 'video'] }
});

// 3. Check creative formats
const formats = await agent.listCreativeFormats({
  format_types: ['display', 'video']
});

// 4. Create campaign
const campaign = await agent.createMediaBuy({
  buyer_ref: 'q1-2026-awareness',
  brand_manifest: { url: 'https://startup.com' },
  packages: [
    {
      buyer_ref: 'pkg-001',
      product_id: products.products[0].product_id,
      pricing_option_id: 'cpm-standard',
      budget: 15000
    }
  ],
  start_time: { type: 'asap' },
  end_time: '2026-03-31T23:59:59Z'
});

// 5. Upload creatives
await agent.syncCreatives({
  creatives: [...], // Your creative assets
  assignments: {
    'creative_001': ['pkg-001']
  }
});

// 6. Monitor performance
const delivery = await agent.getMediaBuyDelivery({
  media_buy_id: campaign.media_buy_id
});

Workflow 2: Update Running Campaign

// Pause, adjust budget, and resume campaign
await agent.updateMediaBuy({
  media_buy_id: 'mb_abc123',
  updates: {
    status: 'paused',
    budget_change: 5000, // Add $5000
    end_time: '2026-04-30T23:59:59Z'
  }
});

// Resume after adjustments
await agent.updateMediaBuy({
  media_buy_id: 'mb_abc123',
  updates: { status: 'active' }
});

More workflow examples: See EXAMPLES.md for complete campaign scenarios including creative management, multi-channel campaigns, and optimization workflows.

Test Agent

For development and testing, use the public test agent:

Agent URL: https://test-agent.adcontextprotocol.org/mcp
Auth Token: 1v8tAhASaUYYp4odoQ1PnMpdqNaMiTrCRqYo9OJp6IQ

import { testAgent } from '@adcp/client/testing';

// No authentication needed for test agent
const result = await testAgent.getProducts({
  brief: 'Test campaign',
  brand_manifest: { url: 'https://example.com' }
});

Interactive testing available at: testing.adcontextprotocol.org

Error Handling

Common error patterns:

400 Bad Request - Invalid parameters:

{
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "budget must be greater than 0",
    "field": "packages[0].budget"
  }
}

401 Unauthorized - Missing or invalid auth:

{
  "error": {
    "code": "UNAUTHORIZED",
    "message": "Invalid authentication token"
  }
}

404 Not Found - Invalid ID reference:

{
  "error": {
    "code": "NOT_FOUND",
    "message": "Product not found",
    "resource": "product_id: premium_video_30s"
  }
}

Always check for errors before processing responses:

if (result.error) {
  console.error(`Error: ${result.error.message}`);
  return;
}

Best Practices

1. Always Start with Capabilities

Call get_adcp_capabilities first to understand what the agent supports before making other requests.

2. Use Clear Buyer References

Use descriptive buyer_ref values for tracking:

• Good: 'campaign-2026-q1-tech-launch'
• Avoid: 'c1', 'test', 'abc'

3. Handle Async Operations

Check status field and implement polling for pending operations:

let status = 'pending';
while (status === 'pending') {
  await sleep(5000); // Wait 5 seconds
  const update = await agent.getMediaBuyDelivery({
    media_buy_id: campaign.media_buy_id
  });
  status = update.status;
}

4. Write Detailed Briefs

Better briefs lead to better product matches:

• Good: 'Premium video inventory for luxury automotive brand targeting high-income professionals aged 35-54 in major metros. Focus on brand awareness with completion rates above 70%.'
• Avoid: 'video ads', 'need advertising'

5. Validate Creative Formats

Always check list_creative_formats to ensure your creatives meet requirements before uploading.

6. Monitor Budget Pacing

Regularly check delivery metrics to ensure campaigns are pacing properly:

const delivery = await agent.getMediaBuyDelivery({
  media_buy_id: campaign.media_buy_id
});

const pacing = delivery.delivery.spend / delivery.delivery.budget;
console.log(`Budget pacing: ${(pacing * 100).toFixed(1)}%`);

Additional Resources

Official AdCP Documentation

• Main Documentation: https://docs.adcontextprotocol.org
• Complete Index: https://docs.adcontextprotocol.org/llms.txt
• Media Buy Protocol: https://docs.adcontextprotocol.org/docs/media-buy/
• Quick Reference: https://docs.adcontextprotocol.org/docs/media-buy/quick-reference
• Task Reference: https://docs.adcontextprotocol.org/docs/media-buy/task-reference/
• Quickstart Guide: https://docs.adcontextprotocol.org/docs/quickstart

This Skill's Documentation

• REFERENCE.md - Complete API reference and schemas
• EXAMPLES.md - Real-world campaign examples
• PROTOCOLS.md - MCP vs A2A protocol details
• TARGETING.md - Advanced targeting strategies
• CREATIVE.md - Creative asset management guide

Key Reminders

1. AdCP is asynchronous - Operations may take minutes to days
2. Human approval may be required - Check for pending status
3. Start with capabilities - Always call get_adcp_capabilities first
4. Brand context matters - Provide detailed brand manifests for better results
5. Targeting is additive - Product targeting + your overlay = final targeting
6. Creative formats are strict - Always validate against format specifications
7. Monitor performance - Regular delivery checks ensure campaign success

Support

For help with AdCP:

• Official Repository: https://github.com/adcontextprotocol/adcp
• Documentation: https://docs.adcontextprotocol.org
• Interactive Testing: https://testing.adcontextprotocol.org
• Complete API Docs: https://docs.adcontextprotocol.org/llms.txt

Ad Context Protocol (AdCP) Advertising Skill for OpenClaw

Launch and optimize advertising campaigns using AI. Automate media buying, ad creation, campaign management, and performance tracking across display, video, CTV, audio, and more.

Official AdCP Repository: github.com/adcontextprotocol/adcp
Official AdCP Documentation: https://docs.adcontextprotocol.org
Complete Documentation Index: https://docs.adcontextprotocol.org/llms.txt

Overview

Transform how you run advertising campaigns. This skill provides OpenClaw agents with AI-powered advertising automation:

• 🔍 Discover ad inventory - Find display ads, video placements, CTV spots using natural language
• 🎯 Launch campaigns instantly - Create multi-channel campaigns across display, video, CTV, audio, native, DOOH
• 🎨 Manage ad creatives - Upload banners, videos, HTML5 ads and track performance by creative
• 📊 Monitor ROI in real-time - Get impressions, clicks, conversions, CPM, CTR, and spend data instantly
• 🎛️ Auto-optimize performance - Reallocate budgets, pause underperformers, scale winners automatically
• 🌐 Target precisely - Demographics, behaviors, interests, locations, devices, times, and contexts

Perfect For

Marketing teams running Facebook ads, Google ads, programmatic campaigns
Media buyers managing multi-channel ad spend and inventory
Agencies automating client campaign management and reporting
E-commerce launching product ads and retargeting campaigns
Startups running lean marketing with AI-powered ad automation

Quick Start

Installation

For ClawHub users:

# Install via ClawHub
openclaw skills install adcp-advertising

For local development:

# Clone or download this skill to your workspace
cd ~/.openclaw/workspace/skills/
git clone <this-repo> adcp-advertising

Launch Your First Ad Campaign in 5 Minutes

Go from zero to live campaign using just natural language. No forms, no dashboards, no ad platform expertise needed.

Step 1: Discover what's available (No login required)

"Show me advertising options for my business"

Browse inventory across publishers without authentication.

Step 2: Find your perfect ad placement

"Find display ads for a tech startup, $5000 budget"

AI searches inventory and shows matching products with pricing.

Step 3: Launch your campaign

"Create campaign with Product ID prod_abc123, $5000 budget, 
targeting tech professionals in California"

Campaign goes live instantly using the test environment.

Step 4: Upload your ads

"Upload this banner as a creative"

Drop your image, video, or HTML5 ad. Done.

Step 5: Track performance

"Show campaign performance"

Get impressions, clicks, CTR, spend, and pacing in real-time.

That's it! Your first campaign is live in the test environment. When ready, switch to production for real ad delivery.

Moving to Production

Ready for real ad delivery? Switch seamlessly:

1. Find sales agents: get_adcp_capabilities on production endpoints
2. Get credentials from their sales team
3. Update agent URL to production
4. Launch campaigns with real budgets

Why Choose This Skill?

Say Goodbye to Ad Platform Complexity

• No more dashboards - Manage everything through conversation
• No forms to fill - Just describe what you want in plain English
• No platform learning curve - AI handles the technical details
• No manual optimization - Automated performance management

Built for Results

• Launch faster - 5 minutes from idea to live campaign vs. hours in traditional platforms
• Spend smarter - AI-powered optimization reallocates budgets to top performers
• Scale easier - Manage unlimited campaigns through simple commands
• Track better - Real-time metrics without dashboard switching

Trusted Technology

• Open standard - Built on Ad Context Protocol used by real advertising platforms
• Production-ready - Complete error handling, validation, and best practices
• Well-documented - 5,600+ lines of guides, examples, and references
• Test environment included - Try everything risk-free before going live

Features

🔍 Product Discovery

• Natural language search for advertising inventory
• Filter by channel, budget, format, and date range
• Detailed product information including pricing and targeting options

🎯 Campaign Management

• Create campaigns across multiple channels
• Update budgets, targeting, and creative assignments
• Pause/resume campaigns
• Schedule campaigns for future launch

🎨 Creative Management

• Support for all standard IAB formats (display, video, native)
• Bulk creative upload
• Creative library management
• Performance tracking by creative

📊 Performance Monitoring

• Real-time campaign metrics
• Detailed breakdowns by package, creative, and geography
• Budget pacing alerts
• Daily/hourly granularity

🎛️ Optimization

• Automatic budget reallocation based on performance
• A/B testing for creatives
• Targeting optimization recommendations
• Pacing adjustments

Supported Channels

• Display: Banner ads, rich media, HTML5
• Video: Pre-roll, mid-roll, outstream
• CTV: Connected TV advertising
• Audio: Streaming audio, podcast ads
• Native: In-feed, content-style ads
• DOOH: Digital out-of-home advertising

Documentation

Comprehensive documentation is included with this skill:

• SKILL.md - Main skill guide with quick start and core concepts
• REFERENCE.md - Complete API reference for all 8 AdCP tasks
• EXAMPLES.md - Real-world campaign examples and use cases
• PROTOCOLS.md - MCP vs A2A protocol details
• TARGETING.md - Advanced targeting strategies
• CREATIVE.md - Creative asset management guide

Example Workflows

Launch a Simple Campaign

Agent: "I need to run a display campaign for my startup"

System discovers products, shows options

Agent: "Create a campaign with Product 1, $10,000 budget, 
       targeting tech professionals in California"

System creates campaign

Agent: "Upload my 300x250 banner to this campaign"

System uploads creative and assigns to campaign

Monitor and Optimize

Agent: "Show me how my video campaign is performing"

System shows metrics: impressions, CTR, spend, pacing

Agent: "Which creative is performing best?"

System analyzes and shows creative performance rankings

Agent: "Shift $5,000 from package B to package A 
       since it's performing better"

System updates budget allocation

Authentication

AdCP uses a tiered authentication model - some operations are public, others require credentials.

Public Operations (No Auth Required)

These work without any credentials:

• get_adcp_capabilities - Discover agent capabilities and portfolio
• list_creative_formats - Browse available ad formats
• get_products (limited) - Basic inventory discovery (partial catalog, no pricing)

Why? Publishers want potential buyers to explore capabilities before establishing relationships.

Authenticated Operations (Credentials Required)

Everything else needs authentication:

• get_products (full) - Complete catalog with pricing and custom products
• create_media_buy - Create advertising campaigns
• update_media_buy - Modify existing campaigns
• sync_creatives - Upload creative assets
• list_creatives - View your creative library
• get_media_buy_delivery - Monitor campaign performance
• provide_performance_feedback - Submit optimization signals

Authentication Method

AdCP uses Bearer token authentication:

Authorization: Bearer <your-token>

Tokens can be:

• Opaque tokens: Server-validated strings
• JWT tokens: Self-contained with embedded claims

Test Agent (Public Credentials)

A public test agent is available with shared credentials for development:

• Agent URL: https://test-agent.adcontextprotocol.org/mcp
• Auth Token: 1v8tAhASaUYYp4odoQ1PnMpdqNaMiTrCRqYo9OJp6IQ
• Interactive Testing: testing.adcontextprotocol.org

This token is intentionally public - anyone can use it for testing. It's included in package.json and official AdCP documentation.

Production Credentials

For real campaigns, you need credentials from each sales agent:

1. Discover agents: Use get_adcp_capabilities on production endpoints
2. Contact sales: Reach out to the agent's sales/partnerships team
3. Complete onboarding: Provide business info, sign agreements, configure billing
4. Receive credentials: Get your API Bearer token or OAuth credentials
5. Store securely: Use environment variables or secret managers (never commit to git)

Important: Each sales agent manages credentials independently. You need separate auth for each one you work with.

Example Configuration

Test environment:

{
  "agent_url": "https://test-agent.adcontextprotocol.org/mcp",
  "auth": {
    "type": "bearer",
    "token": "1v8tAhASaUYYp4odoQ1PnMpdqNaMiTrCRqYo9OJp6IQ"
  }
}

Production environment:

{
  "agent_url": "https://sales-agent.example.com/mcp",
  "auth": {
    "type": "bearer",
    "token": "your-production-token-here"
  }
}

For more details, see the official authentication guide.

Key Concepts

Asynchronous Operations

AdCP is not a real-time protocol. Operations may take:

• ~1 second: Simple lookups (formats, creative lists)
• ~60 seconds: AI operations (product discovery)
• Minutes to days: Operations requiring approval (campaign creation)

Always check the status field and handle pending states.

Targeting is Additive

Your targeting overlay + Product targeting = Final targeting

Products already have targeting. Your overlay adds constraints.

Brand Context Matters

Provide detailed brand manifests for better product matches:

{
  brand_manifest: {
    name: 'Acme Corp',
    url: 'https://acme.com',
    tagline: 'Innovation that matters',
    colors: { primary: '#FF4500' }
  }
}

Who Should Use This Skill?

Marketing Teams

• Launch campaigns faster without learning complex platforms
• Monitor multiple campaigns through conversational queries
• Get instant performance insights and optimization recommendations

Media Buyers

• Discover inventory across multiple publishers at once
• Compare products and pricing using natural language
• Automate routine optimization tasks

Agencies

• Manage client campaigns through AI agents
• Scale operations without proportional staff increases
• Standardize workflows across different platforms

Developers

• Build advertising automation tools
• Integrate ad buying into larger workflows
• Access advertising APIs through natural language

Common Use Cases

Launch New Product Campaign

Agent: "I need to launch a campaign for our new SaaS product targeting 
        CTOs and tech directors in major US cities, $50,000 budget"

System: Discovers suitable products, creates multi-package campaign, 
        sets up targeting, and uploads provided creatives

Optimize Existing Campaign

Agent: "Analyze my video campaign performance and recommend optimizations"

System: Reviews metrics, identifies top performers, suggests budget 
        reallocation, pauses underperforming elements

Multi-Channel Strategy

Agent: "Create an omnichannel campaign: display in California, 
        video in major cities, audio during commute hours"

System: Creates coordinated campaign across channels with unified 
        targeting and creative strategy

Requirements

• OpenClaw: Compatible with OpenClaw 2026.1.0+
• Node.js: 18+ (for JavaScript examples)
• Python: 3.9+ (for Python examples)

Support & Resources

Official AdCP Resources

• Official Repository: https://github.com/adcontextprotocol/adcp
• Main Documentation: https://docs.adcontextprotocol.org
• Complete Index (for AI agents): https://docs.adcontextprotocol.org/llms.txt
• Media Buy Protocol: https://docs.adcontextprotocol.org/docs/media-buy/
• Task Reference: https://docs.adcontextprotocol.org/docs/media-buy/task-reference/
• Quickstart Guide: https://docs.adcontextprotocol.org/docs/quickstart
• Interactive Testing: https://testing.adcontextprotocol.org

This Skill Repository

• Repository: https://github.com/edyyy62/openclaw-adcp
• Issues: https://github.com/edyyy62/openclaw-adcp/issues

OpenClaw Resources

• OpenClaw Docs: https://docs.openclaw.ai
• ClawHub: https://www.clawhub.ai/

License

This skill is provided under the MIT License. See LICENSE for details.

Contributing

Contributions are welcome! Please submit issues or pull requests on GitHub.

Version

Version: 1.0.0
Last Updated: January 2026
AdCP Version: 3.x compatible

Author

Created for the OpenClaw community to enable AI-powered advertising automation.

Acknowledgments

• Ad Context Protocol team for the comprehensive advertising API
• OpenClaw community for the excellent AI assistant framework
• ClawHub for skill distribution infrastructure